file_name
large_stringlengths 4
140
| prefix
large_stringlengths 0
12.1k
| suffix
large_stringlengths 0
12k
| middle
large_stringlengths 0
7.51k
| fim_type
large_stringclasses 4
values |
|---|---|---|---|---|
utils.py | } -- config file containing data paths and tokenizer information
metadata {bool} -- whether the data contains metadata for augmented embeddings
proportion {float} -- proportion for splitting up train and test. (default: {0.7})
max_len {int} -- maximum token length for a text. (default: {128})
partition {dict} -- maps lists of training and validation data IDs (default: {None})
labels {dict} -- (default: {None})
Returns:
partition {dict} -- list of ids in train and valid datasets
torch.utils.data.Dataset -- dataset
"""
# columns if meta: [0] unique ID, [1] text, [2] metadata, [3] label
# columns if no meta: [0] unique ID, [1] text, [2] label
if config["metadata"]:
unique_id_col = 0
text_col = 1
metadata_col = 2
label_col = 3
else:
unique_id_col = 0
text_col = 1
label_col = 3
dataset = pd.read_csv(config['train_file'], header=None, sep='\t')
print(dataset)
# below fix null values wrecking encode_plus
# convert labels to integer and drop nas
dataset.iloc[:, label_col] = pd.to_numeric(dataset.iloc[:, label_col], errors = 'coerce' )
dataset = dataset[~ dataset[text_col].isnull()]
# recreate the first column with the reset index.
dataset = dataset[(dataset.iloc[:, label_col] == 1) | (dataset.iloc[:, label_col] == 0)] \
.reset_index().reset_index().drop(columns = ['index', 0]).rename(columns = {'level_0': 0})
print(dataset)
# create list of train/valid IDs if not provided
if not partition and not labels:
ids = list(dataset.iloc[:,unique_id_col])
total_len = len(ids)
np.random.shuffle(ids)
labels = {}
# metadata = {}
partition = {'train': ids[ :int(total_len * 0.7)], | labels[i] = dataset.iloc[i][label_col]
# set parameters for DataLoader -- num_workers = cores
params = {'batch_size': 32,
'shuffle': True,
'num_workers': 0
}
tokenizer = AutoTokenizer.from_pretrained(vocab)
dataset[text_col] = dataset[text_col].apply(lambda x: tokenizer.encode_plus(str(x), \
max_length=max_len, \
add_special_tokens=True, \
pad_to_max_length=True, \
truncation=True))
if config['metadata']: # glove for metadata preprocessing
glove = torchtext.vocab.GloVe(name="6B", dim=50)
dataset[metadata_col] = dataset[metadata_col].apply(lambda y: __pad__(str(y).split(" "), 30))
dataset[metadata_col] = dataset[metadata_col].apply(lambda z: __glove_embed__(z, glove))
train_data = dataset[dataset[unique_id_col].isin(partition['train'])]
valid_data = dataset[dataset[unique_id_col].isin(partition['valid'])]
# create train/valid generators
training_set = AbstractDataset(data=train_data, labels=labels, metadata=config['metadata'], list_IDs=partition['train'], max_len = max_len)
training_generator = DataLoader(training_set, **params)
validation_set = AbstractDataset(data=valid_data, labels=labels, metadata=config['metadata'], list_IDs=partition['valid'],max_len = max_len)
validation_generator = DataLoader(validation_set, **params)
return partition, training_generator, validation_generator
def __pad__(sequence, max_l):
""" Padding function for 1D sequences """
if max_l - len(sequence) < 0:
sequence = sequence[:max_l]
else:
sequence = np.pad(sequence, (0, max_l - (len(sequence))), 'constant', constant_values=(0))
return sequence
def __glove_embed__(sequence, model):
""" Embed words in a sequence using GLoVE model """
embedded = []
for word in sequence:
embedded.append(model[word])
return embedded
def load_embeddings(config, name, vocab, training_generator, validation_generator):
"""Load embeddings either from cache or from scratch
Args:
config (json) -- file configurations.
name --
vocab --
training_generator --
validation_generator --
Returns:
embedding_shape, train_embeddings, valid_embeddings
"""
# Pickle embeddings should be AGNOSTIC to the name. This is because each pickled embedding is specific to the dataset and transformer.
# Applies down the road when/if we attempt active learning
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_embed_pkl_f):
with open( train_embed_pkl_f, 'rb') as cache:
train_embeddings = pickle.load(cache)
with open(valid_embed_pkl_f, 'rb') as cache:
valid_embeddings = pickle.load(cache)
else:
# get embeddings from scratch
tokenizer = AutoTokenizer.from_pretrained(vocab)
embedding_model = AbstractBert(vocab)
if torch.cuda.device_count() > 1:
print("GPUs Available: ", torch.cuda.device_count())
embedding_model = torch.nn.DataParallel(embedding_model, device_ids=[0, 1, 2])
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
embedding_model.eval().to(device)
logger.info(' Getting BERT/ROBERTA embeddings...')
train_embeddings = _get_bert_embeddings(training_generator, embedding_model, config["metadata"])
valid_embeddings = _get_bert_embeddings(validation_generator, embedding_model, config["metadata"])
# save embeddings
pickle.dump(train_embeddings, open(train_embed_pkl_f, 'wb'))
pickle.dump(valid_embeddings, open(valid_embed_pkl_f, 'wb'))
logger.info(' Saved full BERT/ROBERTA embeddings.')
embedding_shape = train_embeddings['embeddings'][1].shape[0]
return embedding_shape, train_embeddings, valid_embeddings
def _get_bert_embeddings(data_generator, embedding_model: torch.nn.Module, metadata: False):
"""Get BERT embeddings from a dataloader generator.
Arguments:
data_generator {data.Dataset} -- dataloader generator (AbstractDataset).
embedding_model {torch.nn.Module} -- embedding model.
Returns:
embeddings {dict} -- dictionary containing ids, augmented embeddings, and labels.
"""
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
with torch.set_grad_enabled(False):
embeddings = {'ids': [],
'embeddings': [],
'labels': []
}
# get BERT training embeddings
if metadata:
for local_ids, local_data, local_meta, local_labels in data_generator:
local_data, local_meta, local_labels = local_data.to(device).long().squeeze(1), \
local_meta, \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data, local_meta)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
else:
for local_ids, local_data, local_labels in data_generator:
local_data, local_labels = local_data.to(device).long().squeeze(1), \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
return embeddings
def get_pca_embeddings(config, name, training_embedding: dict, validation_embedding: dict):
"""Reduced embeddings using PCA.
Args:
training_embedding (dict) -- dictionary containing training embeddings
validation_embedding (dict) -- dictionary containing validation embeddings
Returns:
generator -- Torch Dataloader
tuple -- shape of embedding
"""
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_pca_pkl_f):
logger.info(" Loading PCA-embeddings from cache ")
with open(train_pca_pkl_f , 'rb') as cache:
train_embeddings = pickle.load | 'valid': ids[int(total_len * 0.7): ]
}
for i in dataset.iloc[:, unique_id_col]: | random_line_split |
utils.py | } -- config file containing data paths and tokenizer information
metadata {bool} -- whether the data contains metadata for augmented embeddings
proportion {float} -- proportion for splitting up train and test. (default: {0.7})
max_len {int} -- maximum token length for a text. (default: {128})
partition {dict} -- maps lists of training and validation data IDs (default: {None})
labels {dict} -- (default: {None})
Returns:
partition {dict} -- list of ids in train and valid datasets
torch.utils.data.Dataset -- dataset
"""
# columns if meta: [0] unique ID, [1] text, [2] metadata, [3] label
# columns if no meta: [0] unique ID, [1] text, [2] label
if config["metadata"]:
unique_id_col = 0
text_col = 1
metadata_col = 2
label_col = 3
else:
unique_id_col = 0
text_col = 1
label_col = 3
dataset = pd.read_csv(config['train_file'], header=None, sep='\t')
print(dataset)
# below fix null values wrecking encode_plus
# convert labels to integer and drop nas
dataset.iloc[:, label_col] = pd.to_numeric(dataset.iloc[:, label_col], errors = 'coerce' )
dataset = dataset[~ dataset[text_col].isnull()]
# recreate the first column with the reset index.
dataset = dataset[(dataset.iloc[:, label_col] == 1) | (dataset.iloc[:, label_col] == 0)] \
.reset_index().reset_index().drop(columns = ['index', 0]).rename(columns = {'level_0': 0})
print(dataset)
# create list of train/valid IDs if not provided
if not partition and not labels:
ids = list(dataset.iloc[:,unique_id_col])
total_len = len(ids)
np.random.shuffle(ids)
labels = {}
# metadata = {}
partition = {'train': ids[ :int(total_len * 0.7)],
'valid': ids[int(total_len * 0.7): ]
}
for i in dataset.iloc[:, unique_id_col]:
labels[i] = dataset.iloc[i][label_col]
# set parameters for DataLoader -- num_workers = cores
params = {'batch_size': 32,
'shuffle': True,
'num_workers': 0
}
tokenizer = AutoTokenizer.from_pretrained(vocab)
dataset[text_col] = dataset[text_col].apply(lambda x: tokenizer.encode_plus(str(x), \
max_length=max_len, \
add_special_tokens=True, \
pad_to_max_length=True, \
truncation=True))
if config['metadata']: # glove for metadata preprocessing
glove = torchtext.vocab.GloVe(name="6B", dim=50)
dataset[metadata_col] = dataset[metadata_col].apply(lambda y: __pad__(str(y).split(" "), 30))
dataset[metadata_col] = dataset[metadata_col].apply(lambda z: __glove_embed__(z, glove))
train_data = dataset[dataset[unique_id_col].isin(partition['train'])]
valid_data = dataset[dataset[unique_id_col].isin(partition['valid'])]
# create train/valid generators
training_set = AbstractDataset(data=train_data, labels=labels, metadata=config['metadata'], list_IDs=partition['train'], max_len = max_len)
training_generator = DataLoader(training_set, **params)
validation_set = AbstractDataset(data=valid_data, labels=labels, metadata=config['metadata'], list_IDs=partition['valid'],max_len = max_len)
validation_generator = DataLoader(validation_set, **params)
return partition, training_generator, validation_generator
def __pad__(sequence, max_l):
""" Padding function for 1D sequences """
if max_l - len(sequence) < 0:
|
else:
sequence = np.pad(sequence, (0, max_l - (len(sequence))), 'constant', constant_values=(0))
return sequence
def __glove_embed__(sequence, model):
""" Embed words in a sequence using GLoVE model """
embedded = []
for word in sequence:
embedded.append(model[word])
return embedded
def load_embeddings(config, name, vocab, training_generator, validation_generator):
"""Load embeddings either from cache or from scratch
Args:
config (json) -- file configurations.
name --
vocab --
training_generator --
validation_generator --
Returns:
embedding_shape, train_embeddings, valid_embeddings
"""
# Pickle embeddings should be AGNOSTIC to the name. This is because each pickled embedding is specific to the dataset and transformer.
# Applies down the road when/if we attempt active learning
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_embed_pkl_f):
with open( train_embed_pkl_f, 'rb') as cache:
train_embeddings = pickle.load(cache)
with open(valid_embed_pkl_f, 'rb') as cache:
valid_embeddings = pickle.load(cache)
else:
# get embeddings from scratch
tokenizer = AutoTokenizer.from_pretrained(vocab)
embedding_model = AbstractBert(vocab)
if torch.cuda.device_count() > 1:
print("GPUs Available: ", torch.cuda.device_count())
embedding_model = torch.nn.DataParallel(embedding_model, device_ids=[0, 1, 2])
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
embedding_model.eval().to(device)
logger.info(' Getting BERT/ROBERTA embeddings...')
train_embeddings = _get_bert_embeddings(training_generator, embedding_model, config["metadata"])
valid_embeddings = _get_bert_embeddings(validation_generator, embedding_model, config["metadata"])
# save embeddings
pickle.dump(train_embeddings, open(train_embed_pkl_f, 'wb'))
pickle.dump(valid_embeddings, open(valid_embed_pkl_f, 'wb'))
logger.info(' Saved full BERT/ROBERTA embeddings.')
embedding_shape = train_embeddings['embeddings'][1].shape[0]
return embedding_shape, train_embeddings, valid_embeddings
def _get_bert_embeddings(data_generator, embedding_model: torch.nn.Module, metadata: False):
"""Get BERT embeddings from a dataloader generator.
Arguments:
data_generator {data.Dataset} -- dataloader generator (AbstractDataset).
embedding_model {torch.nn.Module} -- embedding model.
Returns:
embeddings {dict} -- dictionary containing ids, augmented embeddings, and labels.
"""
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
with torch.set_grad_enabled(False):
embeddings = {'ids': [],
'embeddings': [],
'labels': []
}
# get BERT training embeddings
if metadata:
for local_ids, local_data, local_meta, local_labels in data_generator:
local_data, local_meta, local_labels = local_data.to(device).long().squeeze(1), \
local_meta, \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data, local_meta)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
else:
for local_ids, local_data, local_labels in data_generator:
local_data, local_labels = local_data.to(device).long().squeeze(1), \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
return embeddings
def get_pca_embeddings(config, name, training_embedding: dict, validation_embedding: dict):
"""Reduced embeddings using PCA.
Args:
training_embedding (dict) -- dictionary containing training embeddings
validation_embedding (dict) -- dictionary containing validation embeddings
Returns:
generator -- Torch Dataloader
tuple -- shape of embedding
"""
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_pca_pkl_f):
logger.info(" Loading PCA-embeddings from cache ")
with open(train_pca_pkl_f , 'rb') as cache:
train_embeddings = pickle | sequence = sequence[:max_l] | conditional_block |
utils.py | =None, sep='\t')
print(dataset)
# below fix null values wrecking encode_plus
# convert labels to integer and drop nas
dataset.iloc[:, label_col] = pd.to_numeric(dataset.iloc[:, label_col], errors = 'coerce' )
dataset = dataset[~ dataset[text_col].isnull()]
# recreate the first column with the reset index.
dataset = dataset[(dataset.iloc[:, label_col] == 1) | (dataset.iloc[:, label_col] == 0)] \
.reset_index().reset_index().drop(columns = ['index', 0]).rename(columns = {'level_0': 0})
print(dataset)
# create list of train/valid IDs if not provided
if not partition and not labels:
ids = list(dataset.iloc[:,unique_id_col])
total_len = len(ids)
np.random.shuffle(ids)
labels = {}
# metadata = {}
partition = {'train': ids[ :int(total_len * 0.7)],
'valid': ids[int(total_len * 0.7): ]
}
for i in dataset.iloc[:, unique_id_col]:
labels[i] = dataset.iloc[i][label_col]
# set parameters for DataLoader -- num_workers = cores
params = {'batch_size': 32,
'shuffle': True,
'num_workers': 0
}
tokenizer = AutoTokenizer.from_pretrained(vocab)
dataset[text_col] = dataset[text_col].apply(lambda x: tokenizer.encode_plus(str(x), \
max_length=max_len, \
add_special_tokens=True, \
pad_to_max_length=True, \
truncation=True))
if config['metadata']: # glove for metadata preprocessing
glove = torchtext.vocab.GloVe(name="6B", dim=50)
dataset[metadata_col] = dataset[metadata_col].apply(lambda y: __pad__(str(y).split(" "), 30))
dataset[metadata_col] = dataset[metadata_col].apply(lambda z: __glove_embed__(z, glove))
train_data = dataset[dataset[unique_id_col].isin(partition['train'])]
valid_data = dataset[dataset[unique_id_col].isin(partition['valid'])]
# create train/valid generators
training_set = AbstractDataset(data=train_data, labels=labels, metadata=config['metadata'], list_IDs=partition['train'], max_len = max_len)
training_generator = DataLoader(training_set, **params)
validation_set = AbstractDataset(data=valid_data, labels=labels, metadata=config['metadata'], list_IDs=partition['valid'],max_len = max_len)
validation_generator = DataLoader(validation_set, **params)
return partition, training_generator, validation_generator
def __pad__(sequence, max_l):
""" Padding function for 1D sequences """
if max_l - len(sequence) < 0:
sequence = sequence[:max_l]
else:
sequence = np.pad(sequence, (0, max_l - (len(sequence))), 'constant', constant_values=(0))
return sequence
def __glove_embed__(sequence, model):
""" Embed words in a sequence using GLoVE model """
embedded = []
for word in sequence:
embedded.append(model[word])
return embedded
def load_embeddings(config, name, vocab, training_generator, validation_generator):
"""Load embeddings either from cache or from scratch
Args:
config (json) -- file configurations.
name --
vocab --
training_generator --
validation_generator --
Returns:
embedding_shape, train_embeddings, valid_embeddings
"""
# Pickle embeddings should be AGNOSTIC to the name. This is because each pickled embedding is specific to the dataset and transformer.
# Applies down the road when/if we attempt active learning
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_embed_pkl_f):
with open( train_embed_pkl_f, 'rb') as cache:
train_embeddings = pickle.load(cache)
with open(valid_embed_pkl_f, 'rb') as cache:
valid_embeddings = pickle.load(cache)
else:
# get embeddings from scratch
tokenizer = AutoTokenizer.from_pretrained(vocab)
embedding_model = AbstractBert(vocab)
if torch.cuda.device_count() > 1:
print("GPUs Available: ", torch.cuda.device_count())
embedding_model = torch.nn.DataParallel(embedding_model, device_ids=[0, 1, 2])
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
embedding_model.eval().to(device)
logger.info(' Getting BERT/ROBERTA embeddings...')
train_embeddings = _get_bert_embeddings(training_generator, embedding_model, config["metadata"])
valid_embeddings = _get_bert_embeddings(validation_generator, embedding_model, config["metadata"])
# save embeddings
pickle.dump(train_embeddings, open(train_embed_pkl_f, 'wb'))
pickle.dump(valid_embeddings, open(valid_embed_pkl_f, 'wb'))
logger.info(' Saved full BERT/ROBERTA embeddings.')
embedding_shape = train_embeddings['embeddings'][1].shape[0]
return embedding_shape, train_embeddings, valid_embeddings
def _get_bert_embeddings(data_generator, embedding_model: torch.nn.Module, metadata: False):
"""Get BERT embeddings from a dataloader generator.
Arguments:
data_generator {data.Dataset} -- dataloader generator (AbstractDataset).
embedding_model {torch.nn.Module} -- embedding model.
Returns:
embeddings {dict} -- dictionary containing ids, augmented embeddings, and labels.
"""
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
with torch.set_grad_enabled(False):
embeddings = {'ids': [],
'embeddings': [],
'labels': []
}
# get BERT training embeddings
if metadata:
for local_ids, local_data, local_meta, local_labels in data_generator:
local_data, local_meta, local_labels = local_data.to(device).long().squeeze(1), \
local_meta, \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data, local_meta)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
else:
for local_ids, local_data, local_labels in data_generator:
local_data, local_labels = local_data.to(device).long().squeeze(1), \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
return embeddings
def get_pca_embeddings(config, name, training_embedding: dict, validation_embedding: dict):
"""Reduced embeddings using PCA.
Args:
training_embedding (dict) -- dictionary containing training embeddings
validation_embedding (dict) -- dictionary containing validation embeddings
Returns:
generator -- Torch Dataloader
tuple -- shape of embedding
"""
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_pca_pkl_f):
logger.info(" Loading PCA-embeddings from cache ")
with open(train_pca_pkl_f , 'rb') as cache:
train_embeddings = pickle.load(cache)
with open(valid_pca_pkl_f, 'rb') as cache:
valid_embeddings = pickle.load(cache)
else:
logger.info(' Standardizing ')
ss = StandardScaler()
train_embed_ss = ss.fit_transform(training_embedding['embeddings'])
valid_embed_ss = ss.transform(validation_embedding['embeddings'])
# Dimension reduction: PCA or UMAP (?)
logger.info(' Doing PCA...')
pca_model = decomposition.PCA(n_components = 0.90) # this can be a parameter down the road, but for debugging it's fine
train_reduc = pca_model.fit_transform(train_embed_ss)
val_reduc = pca_model.transform(valid_embed_ss)
training_embedding['embeddings'] = train_reduc
validation_embedding['embeddings'] = val_reduc
train_embeddings = training_embedding.copy()
valid_embeddings = validation_embedding.copy()
# save embeddings
pickle.dump(train_embeddings, open(train_pca_pkl_f, 'wb'))
pickle.dump(valid_embeddings, open(valid_pca_pkl_f, 'wb'))
embedding_shape = len(train_embeddings['embeddings'][0])
return embedding_shape, train_embeddings, valid_embeddings
def | metrics | identifier_name |
|
utils.py | } -- config file containing data paths and tokenizer information
metadata {bool} -- whether the data contains metadata for augmented embeddings
proportion {float} -- proportion for splitting up train and test. (default: {0.7})
max_len {int} -- maximum token length for a text. (default: {128})
partition {dict} -- maps lists of training and validation data IDs (default: {None})
labels {dict} -- (default: {None})
Returns:
partition {dict} -- list of ids in train and valid datasets
torch.utils.data.Dataset -- dataset
"""
# columns if meta: [0] unique ID, [1] text, [2] metadata, [3] label
# columns if no meta: [0] unique ID, [1] text, [2] label
if config["metadata"]:
unique_id_col = 0
text_col = 1
metadata_col = 2
label_col = 3
else:
unique_id_col = 0
text_col = 1
label_col = 3
dataset = pd.read_csv(config['train_file'], header=None, sep='\t')
print(dataset)
# below fix null values wrecking encode_plus
# convert labels to integer and drop nas
dataset.iloc[:, label_col] = pd.to_numeric(dataset.iloc[:, label_col], errors = 'coerce' )
dataset = dataset[~ dataset[text_col].isnull()]
# recreate the first column with the reset index.
dataset = dataset[(dataset.iloc[:, label_col] == 1) | (dataset.iloc[:, label_col] == 0)] \
.reset_index().reset_index().drop(columns = ['index', 0]).rename(columns = {'level_0': 0})
print(dataset)
# create list of train/valid IDs if not provided
if not partition and not labels:
ids = list(dataset.iloc[:,unique_id_col])
total_len = len(ids)
np.random.shuffle(ids)
labels = {}
# metadata = {}
partition = {'train': ids[ :int(total_len * 0.7)],
'valid': ids[int(total_len * 0.7): ]
}
for i in dataset.iloc[:, unique_id_col]:
labels[i] = dataset.iloc[i][label_col]
# set parameters for DataLoader -- num_workers = cores
params = {'batch_size': 32,
'shuffle': True,
'num_workers': 0
}
tokenizer = AutoTokenizer.from_pretrained(vocab)
dataset[text_col] = dataset[text_col].apply(lambda x: tokenizer.encode_plus(str(x), \
max_length=max_len, \
add_special_tokens=True, \
pad_to_max_length=True, \
truncation=True))
if config['metadata']: # glove for metadata preprocessing
glove = torchtext.vocab.GloVe(name="6B", dim=50)
dataset[metadata_col] = dataset[metadata_col].apply(lambda y: __pad__(str(y).split(" "), 30))
dataset[metadata_col] = dataset[metadata_col].apply(lambda z: __glove_embed__(z, glove))
train_data = dataset[dataset[unique_id_col].isin(partition['train'])]
valid_data = dataset[dataset[unique_id_col].isin(partition['valid'])]
# create train/valid generators
training_set = AbstractDataset(data=train_data, labels=labels, metadata=config['metadata'], list_IDs=partition['train'], max_len = max_len)
training_generator = DataLoader(training_set, **params)
validation_set = AbstractDataset(data=valid_data, labels=labels, metadata=config['metadata'], list_IDs=partition['valid'],max_len = max_len)
validation_generator = DataLoader(validation_set, **params)
return partition, training_generator, validation_generator
def __pad__(sequence, max_l):
|
def __glove_embed__(sequence, model):
""" Embed words in a sequence using GLoVE model """
embedded = []
for word in sequence:
embedded.append(model[word])
return embedded
def load_embeddings(config, name, vocab, training_generator, validation_generator):
"""Load embeddings either from cache or from scratch
Args:
config (json) -- file configurations.
name --
vocab --
training_generator --
validation_generator --
Returns:
embedding_shape, train_embeddings, valid_embeddings
"""
# Pickle embeddings should be AGNOSTIC to the name. This is because each pickled embedding is specific to the dataset and transformer.
# Applies down the road when/if we attempt active learning
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_embed_pkl_f):
with open( train_embed_pkl_f, 'rb') as cache:
train_embeddings = pickle.load(cache)
with open(valid_embed_pkl_f, 'rb') as cache:
valid_embeddings = pickle.load(cache)
else:
# get embeddings from scratch
tokenizer = AutoTokenizer.from_pretrained(vocab)
embedding_model = AbstractBert(vocab)
if torch.cuda.device_count() > 1:
print("GPUs Available: ", torch.cuda.device_count())
embedding_model = torch.nn.DataParallel(embedding_model, device_ids=[0, 1, 2])
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
embedding_model.eval().to(device)
logger.info(' Getting BERT/ROBERTA embeddings...')
train_embeddings = _get_bert_embeddings(training_generator, embedding_model, config["metadata"])
valid_embeddings = _get_bert_embeddings(validation_generator, embedding_model, config["metadata"])
# save embeddings
pickle.dump(train_embeddings, open(train_embed_pkl_f, 'wb'))
pickle.dump(valid_embeddings, open(valid_embed_pkl_f, 'wb'))
logger.info(' Saved full BERT/ROBERTA embeddings.')
embedding_shape = train_embeddings['embeddings'][1].shape[0]
return embedding_shape, train_embeddings, valid_embeddings
def _get_bert_embeddings(data_generator, embedding_model: torch.nn.Module, metadata: False):
"""Get BERT embeddings from a dataloader generator.
Arguments:
data_generator {data.Dataset} -- dataloader generator (AbstractDataset).
embedding_model {torch.nn.Module} -- embedding model.
Returns:
embeddings {dict} -- dictionary containing ids, augmented embeddings, and labels.
"""
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
with torch.set_grad_enabled(False):
embeddings = {'ids': [],
'embeddings': [],
'labels': []
}
# get BERT training embeddings
if metadata:
for local_ids, local_data, local_meta, local_labels in data_generator:
local_data, local_meta, local_labels = local_data.to(device).long().squeeze(1), \
local_meta, \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data, local_meta)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
else:
for local_ids, local_data, local_labels in data_generator:
local_data, local_labels = local_data.to(device).long().squeeze(1), \
local_labels.to(device).long()
#print(local_data[0].shape)
augmented_embeddings = embedding_model(local_data)
embeddings['ids'].extend(np.array(local_ids))
embeddings['embeddings'].extend(np.array(augmented_embeddings.detach().cpu()))
embeddings['labels'].extend(np.array(local_labels.detach().cpu().tolist()))
return embeddings
def get_pca_embeddings(config, name, training_embedding: dict, validation_embedding: dict):
"""Reduced embeddings using PCA.
Args:
training_embedding (dict) -- dictionary containing training embeddings
validation_embedding (dict) -- dictionary containing validation embeddings
Returns:
generator -- Torch Dataloader
tuple -- shape of embedding
"""
data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension
train_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')
valid_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')
if os.path.exists(train_pca_pkl_f):
logger.info(" Loading PCA-embeddings from cache ")
with open(train_pca_pkl_f , 'rb') as cache:
train_embeddings = pickle.load | """ Padding function for 1D sequences """
if max_l - len(sequence) < 0:
sequence = sequence[:max_l]
else:
sequence = np.pad(sequence, (0, max_l - (len(sequence))), 'constant', constant_values=(0))
return sequence | identifier_body |
ioapic.rs | 32 {
self.read_reg(0x01)
}
pub fn read_ioapicarb(&mut self) -> u32 {
self.read_reg(0x02)
}
pub fn read_ioredtbl(&mut self, idx: u8) -> u64 {
assert!(idx < 24);
let lo = self.read_reg(0x10 + idx * 2);
let hi = self.read_reg(0x10 + idx * 2 + 1);
u64::from(lo) | (u64::from(hi) << 32)
}
pub fn write_ioredtbl(&mut self, idx: u8, value: u64) {
assert!(idx < 24);
let lo = value as u32;
let hi = (value >> 32) as u32;
self.write_reg(0x10 + idx * 2, lo);
self.write_reg(0x10 + idx * 2 + 1, hi);
}
pub fn max_redirection_table_entries(&mut self) -> u8 {
let ver = self.read_ioapicver();
((ver & 0x00FF_0000) >> 16) as u8
}
pub fn id(&mut self) -> u8 {
let id_reg = self.read_ioapicid();
((id_reg & 0x0F00_0000) >> 24) as u8
}
}
pub struct IoApic {
regs: Mutex<IoApicRegs>,
gsi_start: u32,
count: u8,
}
impl IoApic {
pub fn new(regs_base: *const u32, gsi_start: u32) -> Self {
let mut regs = IoApicRegs { pointer: regs_base };
let count = regs.max_redirection_table_entries();
Self {
regs: Mutex::new(regs),
gsi_start,
count,
}
}
/// Map an interrupt vector to a physical local APIC ID of a processor (thus physical mode).
pub fn map(&self, idx: u8, info: MapInfo) {
self.regs.lock().write_ioredtbl(idx, info.as_raw())
}
pub fn set_mask(&self, gsi: u32, mask: bool) {
let idx = (gsi - self.gsi_start) as u8;
let mut guard = self.regs.lock();
let mut reg = guard.read_ioredtbl(idx);
reg &= !(1 << 16);
reg |= u64::from(mask) << 16;
guard.write_ioredtbl(idx, reg);
}
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum ApicTriggerMode {
Edge = 0,
Level = 1,
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum ApicPolarity {
ActiveHigh = 0,
ActiveLow = 1,
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum DestinationMode {
Physical = 0,
Logical = 1,
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum DeliveryMode {
Fixed = 0b000,
LowestPriority = 0b001,
Smi = 0b010,
Nmi = 0b100,
Init = 0b101,
ExtInt = 0b111,
}
#[derive(Clone, Copy, Debug)]
pub struct MapInfo {
pub dest: u8,
pub mask: bool,
pub trigger_mode: ApicTriggerMode,
pub polarity: ApicPolarity,
pub dest_mode: DestinationMode,
pub delivery_mode: DeliveryMode,
pub vector: u8,
}
impl MapInfo {
pub fn as_raw(&self) -> u64 {
assert!(self.vector >= 0x20);
assert!(self.vector <= 0xFE);
// TODO: Check for reserved fields.
(u64::from(self.dest) << 56)
| (u64::from(self.mask) << 16)
| ((self.trigger_mode as u64) << 15)
| ((self.polarity as u64) << 13)
| ((self.dest_mode as u64) << 11)
| ((self.delivery_mode as u64) << 8)
| u64::from(self.vector)
} | }
impl fmt::Debug for IoApic {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
struct RedirTable<'a>(&'a Mutex<IoApicRegs>);
impl<'a> fmt::Debug for RedirTable<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut guard = self.0.lock();
let count = guard.max_redirection_table_entries();
f.debug_list().entries((0..count).map(|i| guard.read_ioredtbl(i))).finish()
}
}
f.debug_struct("IoApic")
.field("redir_table", &RedirTable(&self.regs))
.field("gsi_start", &self.gsi_start)
.field("count", &self.count)
.finish()
}
}
#[derive(Clone, Copy, Debug)]
pub enum TriggerMode {
ConformsToSpecs,
Edge,
Level,
}
#[derive(Clone, Copy, Debug)]
pub enum Polarity {
ConformsToSpecs,
ActiveHigh,
ActiveLow,
}
#[derive(Clone, Copy, Debug)]
pub struct Override {
bus_irq: u8,
gsi: u32,
trigger_mode: TriggerMode,
polarity: Polarity,
}
// static mut because only the AP initializes the I/O Apic, and when that is done, it's solely
// accessed immutably.
static mut IOAPICS: Option<Vec<IoApic>> = None;
// static mut for the same reason as above
static mut SRC_OVERRIDES: Option<Vec<Override>> = None;
pub fn ioapics() -> &'static [IoApic] {
unsafe {
IOAPICS.as_ref().map_or(&[], |vector| &vector[..])
}
}
pub fn src_overrides() -> &'static [Override] {
unsafe {
SRC_OVERRIDES.as_ref().map_or(&[], |vector| &vector[..])
}
}
#[cfg(feature = "acpi")]
pub unsafe fn handle_ioapic(mapper: &mut KernelMapper, madt_ioapic: &'static MadtIoApic) {
// map the I/O APIC registers
let frame = Frame::containing_address(PhysicalAddress::new(madt_ioapic.address as usize));
let page = Page::containing_address(VirtualAddress::new(crate::IOAPIC_OFFSET));
assert!(mapper.translate(page.start_address()).is_none());
mapper
.get_mut()
.expect("expected KernelMapper not to be locked re-entrant while mapping I/O APIC memory")
.map_phys(page.start_address(), frame.start_address(), PageFlags::new().write(true).custom_flag(EntryFlags::NO_CACHE.bits(), true))
.expect("failed to map I/O APIC")
.flush();
let ioapic_registers = page.start_address().data() as *const u32;
let ioapic = IoApic::new(ioapic_registers, madt_ioapic.gsi_base);
assert_eq!(ioapic.regs.lock().id(), madt_ioapic.id, "mismatched ACPI MADT I/O APIC ID, and the ID reported by the I/O APIC");
IOAPICS.get_or_insert_with(Vec::new).push(ioapic);
}
#[cfg(feature = "acpi")]
pub unsafe fn handle_src_override(src_override: &'static MadtIntSrcOverride) {
let flags = src_override.flags;
let polarity_raw = (flags & 0x0003) as u8;
let trigger_mode_raw = ((flags & 0x000C) >> 2) as u8;
let polarity = match polarity_raw {
0b00 => Polarity::ConformsToSpecs,
0b01 => Polarity::ActiveHigh,
0b10 => return, // reserved
0b11 => Polarity::ActiveLow,
_ => unreachable!(),
};
let trigger_mode = match trigger_mode_raw {
0b00 => TriggerMode::ConformsToSpecs,
0b01 => TriggerMode::Edge,
0b10 => return, // reserved
0b11 => TriggerMode::Level,
_ => unreachable!(),
};
let over = Override {
bus_irq: src_override.irq_source,
gsi: src_override.gsi_base,
polarity,
trigger_mode,
};
SRC_OVERRIDES.get_or_insert_with(Vec::new).push(over);
}
pub unsafe fn init(active_table: &mut KernelMapper) {
let bsp_apic_id = cpuid().unwrap().get_feature_info().unwrap().initial_local_apic_id(); // TODO | random_line_split |
|
ioapic.rs | (self.mask) << 16)
| ((self.trigger_mode as u64) << 15)
| ((self.polarity as u64) << 13)
| ((self.dest_mode as u64) << 11)
| ((self.delivery_mode as u64) << 8)
| u64::from(self.vector)
}
}
impl fmt::Debug for IoApic {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
struct RedirTable<'a>(&'a Mutex<IoApicRegs>);
impl<'a> fmt::Debug for RedirTable<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut guard = self.0.lock();
let count = guard.max_redirection_table_entries();
f.debug_list().entries((0..count).map(|i| guard.read_ioredtbl(i))).finish()
}
}
f.debug_struct("IoApic")
.field("redir_table", &RedirTable(&self.regs))
.field("gsi_start", &self.gsi_start)
.field("count", &self.count)
.finish()
}
}
#[derive(Clone, Copy, Debug)]
pub enum TriggerMode {
ConformsToSpecs,
Edge,
Level,
}
#[derive(Clone, Copy, Debug)]
pub enum Polarity {
ConformsToSpecs,
ActiveHigh,
ActiveLow,
}
#[derive(Clone, Copy, Debug)]
pub struct Override {
bus_irq: u8,
gsi: u32,
trigger_mode: TriggerMode,
polarity: Polarity,
}
// static mut because only the AP initializes the I/O Apic, and when that is done, it's solely
// accessed immutably.
static mut IOAPICS: Option<Vec<IoApic>> = None;
// static mut for the same reason as above
static mut SRC_OVERRIDES: Option<Vec<Override>> = None;
pub fn ioapics() -> &'static [IoApic] {
unsafe {
IOAPICS.as_ref().map_or(&[], |vector| &vector[..])
}
}
pub fn src_overrides() -> &'static [Override] {
unsafe {
SRC_OVERRIDES.as_ref().map_or(&[], |vector| &vector[..])
}
}
#[cfg(feature = "acpi")]
pub unsafe fn handle_ioapic(mapper: &mut KernelMapper, madt_ioapic: &'static MadtIoApic) {
// map the I/O APIC registers
let frame = Frame::containing_address(PhysicalAddress::new(madt_ioapic.address as usize));
let page = Page::containing_address(VirtualAddress::new(crate::IOAPIC_OFFSET));
assert!(mapper.translate(page.start_address()).is_none());
mapper
.get_mut()
.expect("expected KernelMapper not to be locked re-entrant while mapping I/O APIC memory")
.map_phys(page.start_address(), frame.start_address(), PageFlags::new().write(true).custom_flag(EntryFlags::NO_CACHE.bits(), true))
.expect("failed to map I/O APIC")
.flush();
let ioapic_registers = page.start_address().data() as *const u32;
let ioapic = IoApic::new(ioapic_registers, madt_ioapic.gsi_base);
assert_eq!(ioapic.regs.lock().id(), madt_ioapic.id, "mismatched ACPI MADT I/O APIC ID, and the ID reported by the I/O APIC");
IOAPICS.get_or_insert_with(Vec::new).push(ioapic);
}
#[cfg(feature = "acpi")]
pub unsafe fn handle_src_override(src_override: &'static MadtIntSrcOverride) {
let flags = src_override.flags;
let polarity_raw = (flags & 0x0003) as u8;
let trigger_mode_raw = ((flags & 0x000C) >> 2) as u8;
let polarity = match polarity_raw {
0b00 => Polarity::ConformsToSpecs,
0b01 => Polarity::ActiveHigh,
0b10 => return, // reserved
0b11 => Polarity::ActiveLow,
_ => unreachable!(),
};
let trigger_mode = match trigger_mode_raw {
0b00 => TriggerMode::ConformsToSpecs,
0b01 => TriggerMode::Edge,
0b10 => return, // reserved
0b11 => TriggerMode::Level,
_ => unreachable!(),
};
let over = Override {
bus_irq: src_override.irq_source,
gsi: src_override.gsi_base,
polarity,
trigger_mode,
};
SRC_OVERRIDES.get_or_insert_with(Vec::new).push(over);
}
pub unsafe fn init(active_table: &mut KernelMapper) {
let bsp_apic_id = cpuid().unwrap().get_feature_info().unwrap().initial_local_apic_id(); // TODO: remove unwraps
// search the madt for all IOAPICs.
#[cfg(feature = "acpi")]
{
let madt: &'static Madt = match madt::MADT.as_ref() {
Some(m) => m,
// TODO: Parse MP tables too.
None => return,
};
if madt.flags & madt::FLAG_PCAT != 0 {
pic::disable();
}
// find all I/O APICs (usually one).
for entry in madt.iter() {
match entry {
MadtEntry::IoApic(ioapic) => handle_ioapic(active_table, ioapic),
MadtEntry::IntSrcOverride(src_override) => handle_src_override(src_override),
_ => (),
}
}
}
println!("I/O APICs: {:?}, overrides: {:?}", ioapics(), src_overrides());
// map the legacy PC-compatible IRQs (0-15) to 32-47, just like we did with 8259 PIC (if it
// wouldn't have been disabled due to this I/O APIC)
for legacy_irq in 0..=15 {
let (gsi, trigger_mode, polarity) = match get_override(legacy_irq) {
Some(over) => (over.gsi, over.trigger_mode, over.polarity),
None => {
if src_overrides().iter().any(|over| over.gsi == u32::from(legacy_irq) && over.bus_irq != legacy_irq) && !src_overrides().iter().any(|over| over.bus_irq == legacy_irq) {
// there's an IRQ conflict, making this legacy IRQ inaccessible.
continue;
}
(legacy_irq.into(), TriggerMode::ConformsToSpecs, Polarity::ConformsToSpecs)
}
};
let apic = match find_ioapic(gsi) {
Some(ioapic) => ioapic,
None => {
println!("Unable to find a suitable APIC for legacy IRQ {} (GSI {}). It will not be mapped.", legacy_irq, gsi);
continue;
}
};
let redir_tbl_index = (gsi - apic.gsi_start) as u8;
let map_info = MapInfo {
// only send to the BSP
dest: bsp_apic_id,
dest_mode: DestinationMode::Physical,
delivery_mode: DeliveryMode::Fixed,
mask: false,
polarity: match polarity {
Polarity::ActiveHigh => ApicPolarity::ActiveHigh,
Polarity::ActiveLow => ApicPolarity::ActiveLow,
Polarity::ConformsToSpecs => ApicPolarity::ActiveHigh,
},
trigger_mode: match trigger_mode {
TriggerMode::Edge => ApicTriggerMode::Edge,
TriggerMode::Level => ApicTriggerMode::Level,
TriggerMode::ConformsToSpecs => ApicTriggerMode::Edge,
},
vector: 32 + legacy_irq,
};
apic.map(redir_tbl_index, map_info);
}
println!("I/O APICs: {:?}, overrides: {:?}", ioapics(), src_overrides());
irq::set_irq_method(irq::IrqMethod::Apic);
// tell the firmware that we're using APIC rather than the default 8259 PIC.
// FIXME: With ACPI moved to userspace, we should instead allow userspace to check whether the
// IOAPIC has been initialized, and then subsequently let some ACPI driver call the AML from
// userspace.
/*#[cfg(feature = "acpi")]
{
let method = {
let namespace_guard = crate::acpi::ACPI_TABLE.namespace.read();
if let Some(value) = namespace_guard.as_ref().unwrap().get("\\_PIC") {
value.get_as_method().ok()
} else {
None
}
};
if let Some(m) = method {
m.execute("\\_PIC".into(), vec!(crate::acpi::aml::AmlValue::Integer(1)));
}
}*/
}
fn get_override(irq: u8) -> Option<&'static Override> | {
src_overrides().iter().find(|over| over.bus_irq == irq)
} | identifier_body |
|
ioapic.rs | 32 {
self.read_reg(0x01)
}
pub fn read_ioapicarb(&mut self) -> u32 {
self.read_reg(0x02)
}
pub fn read_ioredtbl(&mut self, idx: u8) -> u64 {
assert!(idx < 24);
let lo = self.read_reg(0x10 + idx * 2);
let hi = self.read_reg(0x10 + idx * 2 + 1);
u64::from(lo) | (u64::from(hi) << 32)
}
pub fn write_ioredtbl(&mut self, idx: u8, value: u64) {
assert!(idx < 24);
let lo = value as u32;
let hi = (value >> 32) as u32;
self.write_reg(0x10 + idx * 2, lo);
self.write_reg(0x10 + idx * 2 + 1, hi);
}
pub fn max_redirection_table_entries(&mut self) -> u8 {
let ver = self.read_ioapicver();
((ver & 0x00FF_0000) >> 16) as u8
}
pub fn id(&mut self) -> u8 {
let id_reg = self.read_ioapicid();
((id_reg & 0x0F00_0000) >> 24) as u8
}
}
pub struct IoApic {
regs: Mutex<IoApicRegs>,
gsi_start: u32,
count: u8,
}
impl IoApic {
pub fn new(regs_base: *const u32, gsi_start: u32) -> Self {
let mut regs = IoApicRegs { pointer: regs_base };
let count = regs.max_redirection_table_entries();
Self {
regs: Mutex::new(regs),
gsi_start,
count,
}
}
/// Map an interrupt vector to a physical local APIC ID of a processor (thus physical mode).
pub fn map(&self, idx: u8, info: MapInfo) {
self.regs.lock().write_ioredtbl(idx, info.as_raw())
}
pub fn set_mask(&self, gsi: u32, mask: bool) {
let idx = (gsi - self.gsi_start) as u8;
let mut guard = self.regs.lock();
let mut reg = guard.read_ioredtbl(idx);
reg &= !(1 << 16);
reg |= u64::from(mask) << 16;
guard.write_ioredtbl(idx, reg);
}
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum ApicTriggerMode {
Edge = 0,
Level = 1,
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum ApicPolarity {
ActiveHigh = 0,
ActiveLow = 1,
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum DestinationMode {
Physical = 0,
Logical = 1,
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum DeliveryMode {
Fixed = 0b000,
LowestPriority = 0b001,
Smi = 0b010,
Nmi = 0b100,
Init = 0b101,
ExtInt = 0b111,
}
#[derive(Clone, Copy, Debug)]
pub struct MapInfo {
pub dest: u8,
pub mask: bool,
pub trigger_mode: ApicTriggerMode,
pub polarity: ApicPolarity,
pub dest_mode: DestinationMode,
pub delivery_mode: DeliveryMode,
pub vector: u8,
}
impl MapInfo {
pub fn as_raw(&self) -> u64 {
assert!(self.vector >= 0x20);
assert!(self.vector <= 0xFE);
// TODO: Check for reserved fields.
(u64::from(self.dest) << 56)
| (u64::from(self.mask) << 16)
| ((self.trigger_mode as u64) << 15)
| ((self.polarity as u64) << 13)
| ((self.dest_mode as u64) << 11)
| ((self.delivery_mode as u64) << 8)
| u64::from(self.vector)
}
}
impl fmt::Debug for IoApic {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
struct | <'a>(&'a Mutex<IoApicRegs>);
impl<'a> fmt::Debug for RedirTable<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut guard = self.0.lock();
let count = guard.max_redirection_table_entries();
f.debug_list().entries((0..count).map(|i| guard.read_ioredtbl(i))).finish()
}
}
f.debug_struct("IoApic")
.field("redir_table", &RedirTable(&self.regs))
.field("gsi_start", &self.gsi_start)
.field("count", &self.count)
.finish()
}
}
#[derive(Clone, Copy, Debug)]
pub enum TriggerMode {
ConformsToSpecs,
Edge,
Level,
}
#[derive(Clone, Copy, Debug)]
pub enum Polarity {
ConformsToSpecs,
ActiveHigh,
ActiveLow,
}
#[derive(Clone, Copy, Debug)]
pub struct Override {
bus_irq: u8,
gsi: u32,
trigger_mode: TriggerMode,
polarity: Polarity,
}
// static mut because only the AP initializes the I/O Apic, and when that is done, it's solely
// accessed immutably.
static mut IOAPICS: Option<Vec<IoApic>> = None;
// static mut for the same reason as above
static mut SRC_OVERRIDES: Option<Vec<Override>> = None;
pub fn ioapics() -> &'static [IoApic] {
unsafe {
IOAPICS.as_ref().map_or(&[], |vector| &vector[..])
}
}
pub fn src_overrides() -> &'static [Override] {
unsafe {
SRC_OVERRIDES.as_ref().map_or(&[], |vector| &vector[..])
}
}
#[cfg(feature = "acpi")]
pub unsafe fn handle_ioapic(mapper: &mut KernelMapper, madt_ioapic: &'static MadtIoApic) {
// map the I/O APIC registers
let frame = Frame::containing_address(PhysicalAddress::new(madt_ioapic.address as usize));
let page = Page::containing_address(VirtualAddress::new(crate::IOAPIC_OFFSET));
assert!(mapper.translate(page.start_address()).is_none());
mapper
.get_mut()
.expect("expected KernelMapper not to be locked re-entrant while mapping I/O APIC memory")
.map_phys(page.start_address(), frame.start_address(), PageFlags::new().write(true).custom_flag(EntryFlags::NO_CACHE.bits(), true))
.expect("failed to map I/O APIC")
.flush();
let ioapic_registers = page.start_address().data() as *const u32;
let ioapic = IoApic::new(ioapic_registers, madt_ioapic.gsi_base);
assert_eq!(ioapic.regs.lock().id(), madt_ioapic.id, "mismatched ACPI MADT I/O APIC ID, and the ID reported by the I/O APIC");
IOAPICS.get_or_insert_with(Vec::new).push(ioapic);
}
#[cfg(feature = "acpi")]
pub unsafe fn handle_src_override(src_override: &'static MadtIntSrcOverride) {
let flags = src_override.flags;
let polarity_raw = (flags & 0x0003) as u8;
let trigger_mode_raw = ((flags & 0x000C) >> 2) as u8;
let polarity = match polarity_raw {
0b00 => Polarity::ConformsToSpecs,
0b01 => Polarity::ActiveHigh,
0b10 => return, // reserved
0b11 => Polarity::ActiveLow,
_ => unreachable!(),
};
let trigger_mode = match trigger_mode_raw {
0b00 => TriggerMode::ConformsToSpecs,
0b01 => TriggerMode::Edge,
0b10 => return, // reserved
0b11 => TriggerMode::Level,
_ => unreachable!(),
};
let over = Override {
bus_irq: src_override.irq_source,
gsi: src_override.gsi_base,
polarity,
trigger_mode,
};
SRC_OVERRIDES.get_or_insert_with(Vec::new).push(over);
}
pub unsafe fn init(active_table: &mut KernelMapper) {
let bsp_apic_id = cpuid().unwrap().get_feature_info().unwrap().initial_local_apic_id(); // | RedirTable | identifier_name |
handler.go | existing one.
CreateServiceInstance(*servicecatalog.Instance) (*servicecatalog.Instance, error)
// CreateServiceBinding takes in a (possibly incomplete)
// ServiceBinding and will either create or update an
// existing one.
CreateServiceBinding(*servicecatalog.Binding) (*servicecatalog.Binding, error)
DeleteServiceBinding(*servicecatalog.Binding) error
// CreateServiceBroker takes in a (possibly incomplete)
// ServiceBroker and will either create or update an
// existing one.
CreateServiceBroker(*servicecatalog.Broker) (*servicecatalog.Broker, error)
}
type handler struct {
k8sClient kubernetes.Interface
apiClient apiclient.APIClient
injector injector.BindingInjector
newClientFunc func(name, url, username, password string) brokerapi.BrokerClient
}
func createHandler(k8sClient kubernetes.Interface, client apiclient.APIClient, injector injector.BindingInjector, newClientFn brokerapi.CreateFunc) *handler {
return &handler{
k8sClient: k8sClient,
apiClient: client,
injector: injector,
newClientFunc: newClientFn,
}
}
func (h *handler) updateServiceInstance(in *servicecatalog.Instance) error {
// Currently there's no difference between create / update,
// but for prepping for future, split these into two different
// methods for now.
return h.createServiceInstance(in)
}
func (h *handler) createServiceInstance(in *servicecatalog.Instance) error {
broker, err := util.GetBrokerByServiceClassName(h.apiClient.Brokers(), h.apiClient.ServiceClasses(), in.Spec.ServiceClassName)
if err != nil {
return err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return err
}
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Instance parameters\n%s\n %v", in.Spec.Parameters, err)
return err
}
}
createReq := &brokerapi.CreateServiceInstanceRequest{
ServiceID: in.Spec.OSBServiceID,
PlanID: in.Spec.OSBPlanID,
Parameters: parameters,
}
_, err = client.CreateServiceInstance(in.Spec.OSBGUID, createReq)
return err
}
// GetAuthCredentialsFromBroker returns the auth credentials, if any,
// contained in the secret referenced in the Broker's AuthSecret field, or
// returns an error. If the AuthSecret field is nil, empty values are
// returned.
func GetAuthCredentialsFromBroker(client kubernetes.Interface, broker *servicecatalog.Broker) (username, password string, err error) {
if broker.Spec.AuthSecret == nil {
return "", "", nil
}
authSecret, err := client.Core().Secrets(broker.Spec.AuthSecret.Namespace).Get(broker.Spec.AuthSecret.Name)
if err != nil {
return "", "", err
}
usernameBytes, ok := authSecret.Data["username"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain username")
}
passwordBytes, ok := authSecret.Data["password"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain password")
}
return string(usernameBytes), string(passwordBytes), nil
}
///////////////////////////////////////////////////////////////////////////////
// All the methods implementing the Handler interface go here for clarity sake.
///////////////////////////////////////////////////////////////////////////////
func (h *handler) CreateServiceInstance(in *servicecatalog.Instance) (*servicecatalog.Instance, error) {
serviceID, planID, planName, err := util.GetServicePlanInfo(
h.apiClient.ServiceClasses(),
in.Spec.ServiceClassName,
in.Spec.PlanName,
)
if err != nil {
glog.Errorf("Error fetching service ID: %v", err)
return nil, err
}
in.Spec.OSBServiceID = serviceID
in.Spec.OSBPlanID = planID
in.Spec.PlanName = planName
if in.Spec.OSBGUID == "" {
in.Spec.OSBGUID = uuid.NewV4().String()
}
glog.Infof("Instantiating service %s using service/plan %s : %s", in.Name, serviceID, planID)
err = h.createServiceInstance(in)
in.Status = servicecatalog.InstanceStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionProvisionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionReady,
Status: servicecatalog.ConditionTrue,
},
}
}
glog.Infof("Updating Service %s with State\n%v", in.Name, in.Status.Conditions[0].Type)
return h.apiClient.Instances(in.ObjectMeta.Namespace).Update(in)
}
// DeleteServiceBinding executes all the actions needed before a binding resource can be
// safely deleted. These actions include but are not necessarily limited to deleting the
// kubernetes resources associated with the binding and calling the unbind REST operation
// on the backing OSB API
func (h *handler) DeleteServiceBinding(sb *servicecatalog.Binding) error {
// this logic to set and update the timestamp is TPR specific. to be moved to the API server
dts := metav1.Now()
sb.DeletionTimestamp = &dts
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// uninject
if err := h.injector.Uninject(sb); err != nil {
// if 0 conditions, uninject and drop condition for uninject
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// TODO: unbind && add conditions (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if err := h.unbind(sb); err != nil {
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// This is where the binding is _actually_ deleted after all necessary actions have been taken
if err := h.apiClient.Bindings(sb.Namespace).Delete(sb.Name); err != nil {
// TODO: add deletion error condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
return nil
}
func (h *handler) CreateServiceBinding(in *servicecatalog.Binding) (*servicecatalog.Binding, error) |
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
// Assign UUID to binding.
if in.Spec.OSBGUID == "" {
in.Spec.OSBGUID = uuid.NewV4().String()
}
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Binding parameters\n%s\n %v", in.Spec.Parameters, err)
return nil, err
}
}
createReq := &brokerapi.BindingRequest{
ServiceID: inst.Spec.OSBServiceID,
PlanID: inst.Spec.OSBPlanID,
Parameters: parameters,
}
sbr, err := client.CreateServiceBinding(inst.Spec.OSBGUID, in.Spec.OSBGUID, createReq)
in.Status = servicecatalog.BindingStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.BindingCondition{
{
Type: servicecatalog.BindingConditionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
// Now try injection
err := h.injector.Inject(in, &sbr.Credentials)
if err != nil {
in.Status.Conditions = []servicecatalog.BindingCondition{
{
Type: servicecatalog.BindingConditionFailed,
Status: servicecatalog | {
glog.Infof("Creating Service Binding: %v", in)
inst, err := instanceForBinding(h.apiClient, in)
if err != nil {
return nil, err
}
sc, err := serviceClassForInstance(h.apiClient, inst)
if err != nil {
return nil, err
}
broker, err := brokerForServiceClass(h.apiClient, sc)
if err != nil {
return nil, err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return nil, err
} | identifier_body |
handler.go | existing one.
CreateServiceInstance(*servicecatalog.Instance) (*servicecatalog.Instance, error)
// CreateServiceBinding takes in a (possibly incomplete)
// ServiceBinding and will either create or update an
// existing one.
CreateServiceBinding(*servicecatalog.Binding) (*servicecatalog.Binding, error)
DeleteServiceBinding(*servicecatalog.Binding) error
// CreateServiceBroker takes in a (possibly incomplete)
// ServiceBroker and will either create or update an
// existing one.
CreateServiceBroker(*servicecatalog.Broker) (*servicecatalog.Broker, error)
}
type handler struct {
k8sClient kubernetes.Interface
apiClient apiclient.APIClient
injector injector.BindingInjector
newClientFunc func(name, url, username, password string) brokerapi.BrokerClient
}
func createHandler(k8sClient kubernetes.Interface, client apiclient.APIClient, injector injector.BindingInjector, newClientFn brokerapi.CreateFunc) *handler {
return &handler{
k8sClient: k8sClient,
apiClient: client,
injector: injector,
newClientFunc: newClientFn,
}
}
func (h *handler) updateServiceInstance(in *servicecatalog.Instance) error {
// Currently there's no difference between create / update,
// but for prepping for future, split these into two different
// methods for now.
return h.createServiceInstance(in)
}
func (h *handler) createServiceInstance(in *servicecatalog.Instance) error {
broker, err := util.GetBrokerByServiceClassName(h.apiClient.Brokers(), h.apiClient.ServiceClasses(), in.Spec.ServiceClassName)
if err != nil {
return err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return err
}
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Instance parameters\n%s\n %v", in.Spec.Parameters, err)
return err
}
}
createReq := &brokerapi.CreateServiceInstanceRequest{
ServiceID: in.Spec.OSBServiceID,
PlanID: in.Spec.OSBPlanID,
Parameters: parameters,
}
_, err = client.CreateServiceInstance(in.Spec.OSBGUID, createReq)
return err
}
// GetAuthCredentialsFromBroker returns the auth credentials, if any,
// contained in the secret referenced in the Broker's AuthSecret field, or
// returns an error. If the AuthSecret field is nil, empty values are
// returned.
func GetAuthCredentialsFromBroker(client kubernetes.Interface, broker *servicecatalog.Broker) (username, password string, err error) {
if broker.Spec.AuthSecret == nil {
return "", "", nil
}
authSecret, err := client.Core().Secrets(broker.Spec.AuthSecret.Namespace).Get(broker.Spec.AuthSecret.Name)
if err != nil {
return "", "", err
}
usernameBytes, ok := authSecret.Data["username"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain username")
}
passwordBytes, ok := authSecret.Data["password"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain password")
}
return string(usernameBytes), string(passwordBytes), nil
}
///////////////////////////////////////////////////////////////////////////////
// All the methods implementing the Handler interface go here for clarity sake.
///////////////////////////////////////////////////////////////////////////////
func (h *handler) CreateServiceInstance(in *servicecatalog.Instance) (*servicecatalog.Instance, error) {
serviceID, planID, planName, err := util.GetServicePlanInfo(
h.apiClient.ServiceClasses(),
in.Spec.ServiceClassName,
in.Spec.PlanName,
)
if err != nil {
glog.Errorf("Error fetching service ID: %v", err)
return nil, err
}
in.Spec.OSBServiceID = serviceID
in.Spec.OSBPlanID = planID
in.Spec.PlanName = planName
if in.Spec.OSBGUID == "" {
in.Spec.OSBGUID = uuid.NewV4().String()
}
glog.Infof("Instantiating service %s using service/plan %s : %s", in.Name, serviceID, planID)
err = h.createServiceInstance(in)
in.Status = servicecatalog.InstanceStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionProvisionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionReady,
Status: servicecatalog.ConditionTrue,
},
}
}
glog.Infof("Updating Service %s with State\n%v", in.Name, in.Status.Conditions[0].Type)
return h.apiClient.Instances(in.ObjectMeta.Namespace).Update(in)
}
// DeleteServiceBinding executes all the actions needed before a binding resource can be
// safely deleted. These actions include but are not necessarily limited to deleting the
// kubernetes resources associated with the binding and calling the unbind REST operation
// on the backing OSB API
func (h *handler) DeleteServiceBinding(sb *servicecatalog.Binding) error {
// this logic to set and update the timestamp is TPR specific. to be moved to the API server
dts := metav1.Now()
sb.DeletionTimestamp = &dts
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// uninject
if err := h.injector.Uninject(sb); err != nil {
// if 0 conditions, uninject and drop condition for uninject
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// TODO: unbind && add conditions (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if err := h.unbind(sb); err != nil {
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// This is where the binding is _actually_ deleted after all necessary actions have been taken
if err := h.apiClient.Bindings(sb.Namespace).Delete(sb.Name); err != nil {
// TODO: add deletion error condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
return nil
}
func (h *handler) CreateServiceBinding(in *servicecatalog.Binding) (*servicecatalog.Binding, error) {
glog.Infof("Creating Service Binding: %v", in)
inst, err := instanceForBinding(h.apiClient, in)
if err != nil {
return nil, err
}
sc, err := serviceClassForInstance(h.apiClient, inst)
if err != nil {
return nil, err
}
broker, err := brokerForServiceClass(h.apiClient, sc)
if err != nil {
return nil, err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return nil, err
}
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
// Assign UUID to binding.
if in.Spec.OSBGUID == "" |
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Binding parameters\n%s\n %v", in.Spec.Parameters, err)
return nil, err
}
}
createReq := &brokerapi.BindingRequest{
ServiceID: inst.Spec.OSBServiceID,
PlanID: inst.Spec.OSBPlanID,
Parameters: parameters,
}
sbr, err := client.CreateServiceBinding(inst.Spec.OSBGUID, in.Spec.OSBGUID, createReq)
in.Status = servicecatalog.BindingStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.BindingCondition{
{
Type: servicecatalog.BindingConditionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
// Now try injection
err := h.injector.Inject(in, &sbr.Credentials)
if err != nil {
in.Status.Conditions = []servicecatalog.BindingCondition{
{
Type: servicecatalog.BindingConditionFailed,
Status: servicecatalog | {
in.Spec.OSBGUID = uuid.NewV4().String()
} | conditional_block |
handler.go | catalogURLFormatString = "%s/v2/catalog"
serviceInstanceFormatString = "%s/v2/service_instances/%s"
bindingFormatString = "%s/v2/service_instances/%s/service_bindings/%s"
defaultNamespace = "default"
)
// Handler defines an interface used as a facade for data access operations.
// The controller uses the functions of this interface as callbacks for various
// events.
type Handler interface {
// CreateServiceInstance takes in a (possibly incomplete)
// ServiceInstance and will either create or update an
// existing one.
CreateServiceInstance(*servicecatalog.Instance) (*servicecatalog.Instance, error)
// CreateServiceBinding takes in a (possibly incomplete)
// ServiceBinding and will either create or update an
// existing one.
CreateServiceBinding(*servicecatalog.Binding) (*servicecatalog.Binding, error)
DeleteServiceBinding(*servicecatalog.Binding) error
// CreateServiceBroker takes in a (possibly incomplete)
// ServiceBroker and will either create or update an
// existing one.
CreateServiceBroker(*servicecatalog.Broker) (*servicecatalog.Broker, error)
}
type handler struct {
k8sClient kubernetes.Interface
apiClient apiclient.APIClient
injector injector.BindingInjector
newClientFunc func(name, url, username, password string) brokerapi.BrokerClient
}
func createHandler(k8sClient kubernetes.Interface, client apiclient.APIClient, injector injector.BindingInjector, newClientFn brokerapi.CreateFunc) *handler {
return &handler{
k8sClient: k8sClient,
apiClient: client,
injector: injector,
newClientFunc: newClientFn,
}
}
func (h *handler) updateServiceInstance(in *servicecatalog.Instance) error {
// Currently there's no difference between create / update,
// but for prepping for future, split these into two different
// methods for now.
return h.createServiceInstance(in)
}
func (h *handler) createServiceInstance(in *servicecatalog.Instance) error {
broker, err := util.GetBrokerByServiceClassName(h.apiClient.Brokers(), h.apiClient.ServiceClasses(), in.Spec.ServiceClassName)
if err != nil {
return err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return err
}
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Instance parameters\n%s\n %v", in.Spec.Parameters, err)
return err
}
}
createReq := &brokerapi.CreateServiceInstanceRequest{
ServiceID: in.Spec.OSBServiceID,
PlanID: in.Spec.OSBPlanID,
Parameters: parameters,
}
_, err = client.CreateServiceInstance(in.Spec.OSBGUID, createReq)
return err
}
// GetAuthCredentialsFromBroker returns the auth credentials, if any,
// contained in the secret referenced in the Broker's AuthSecret field, or
// returns an error. If the AuthSecret field is nil, empty values are
// returned.
func GetAuthCredentialsFromBroker(client kubernetes.Interface, broker *servicecatalog.Broker) (username, password string, err error) {
if broker.Spec.AuthSecret == nil {
return "", "", nil
}
authSecret, err := client.Core().Secrets(broker.Spec.AuthSecret.Namespace).Get(broker.Spec.AuthSecret.Name)
if err != nil {
return "", "", err
}
usernameBytes, ok := authSecret.Data["username"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain username")
}
passwordBytes, ok := authSecret.Data["password"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain password")
}
return string(usernameBytes), string(passwordBytes), nil
}
///////////////////////////////////////////////////////////////////////////////
// All the methods implementing the Handler interface go here for clarity sake.
///////////////////////////////////////////////////////////////////////////////
func (h *handler) CreateServiceInstance(in *servicecatalog.Instance) (*servicecatalog.Instance, error) {
serviceID, planID, planName, err := util.GetServicePlanInfo(
h.apiClient.ServiceClasses(),
in.Spec.ServiceClassName,
in.Spec.PlanName,
)
if err != nil {
glog.Errorf("Error fetching service ID: %v", err)
return nil, err
}
in.Spec.OSBServiceID = serviceID
in.Spec.OSBPlanID = planID
in.Spec.PlanName = planName
if in.Spec.OSBGUID == "" {
in.Spec.OSBGUID = uuid.NewV4().String()
}
glog.Infof("Instantiating service %s using service/plan %s : %s", in.Name, serviceID, planID)
err = h.createServiceInstance(in)
in.Status = servicecatalog.InstanceStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionProvisionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionReady,
Status: servicecatalog.ConditionTrue,
},
}
}
glog.Infof("Updating Service %s with State\n%v", in.Name, in.Status.Conditions[0].Type)
return h.apiClient.Instances(in.ObjectMeta.Namespace).Update(in)
}
// DeleteServiceBinding executes all the actions needed before a binding resource can be
// safely deleted. These actions include but are not necessarily limited to deleting the
// kubernetes resources associated with the binding and calling the unbind REST operation
// on the backing OSB API
func (h *handler) DeleteServiceBinding(sb *servicecatalog.Binding) error {
// this logic to set and update the timestamp is TPR specific. to be moved to the API server
dts := metav1.Now()
sb.DeletionTimestamp = &dts
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// uninject
if err := h.injector.Uninject(sb); err != nil {
// if 0 conditions, uninject and drop condition for uninject
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// TODO: unbind && add conditions (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if err := h.unbind(sb); err != nil {
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// This is where the binding is _actually_ deleted after all necessary actions have been taken
if err := h.apiClient.Bindings(sb.Namespace).Delete(sb.Name); err != nil {
// TODO: add deletion error condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
return nil
}
func (h *handler) CreateServiceBinding(in *servicecatalog.Binding) (*servicecatalog.Binding, error) {
glog.Infof("Creating Service Binding: %v", in)
inst, err := instanceForBinding(h.apiClient, in)
if err != nil {
return nil, err
}
sc, err := serviceClassForInstance(h.apiClient, inst)
if err != nil {
return nil, err
}
broker, err := brokerForServiceClass(h.apiClient, sc)
if err != nil {
return nil, err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return nil, err
}
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
// Assign UUID to binding.
if in.Spec.OSBGUID == "" {
in.Spec.OSBGUID = uuid.NewV4().String()
}
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Binding parameters\n%s\n %v", in.Spec.Parameters, err)
return nil, err
}
}
createReq := &brokerapi.BindingRequest{
ServiceID: inst.Spec.OSBServiceID,
PlanID: inst.Spec.OSBPlanID,
Parameters: parameters,
}
sbr, err := client.CreateServiceBinding(inst.Spec.OSBGUID, in.Spec.OSBGUID, createReq)
in.Status = servicecatalog.BindingStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.Binding | random_line_split |
||
handler.go | kubernetes.Interface
apiClient apiclient.APIClient
injector injector.BindingInjector
newClientFunc func(name, url, username, password string) brokerapi.BrokerClient
}
func createHandler(k8sClient kubernetes.Interface, client apiclient.APIClient, injector injector.BindingInjector, newClientFn brokerapi.CreateFunc) *handler {
return &handler{
k8sClient: k8sClient,
apiClient: client,
injector: injector,
newClientFunc: newClientFn,
}
}
func (h *handler) updateServiceInstance(in *servicecatalog.Instance) error {
// Currently there's no difference between create / update,
// but for prepping for future, split these into two different
// methods for now.
return h.createServiceInstance(in)
}
func (h *handler) createServiceInstance(in *servicecatalog.Instance) error {
broker, err := util.GetBrokerByServiceClassName(h.apiClient.Brokers(), h.apiClient.ServiceClasses(), in.Spec.ServiceClassName)
if err != nil {
return err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return err
}
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Instance parameters\n%s\n %v", in.Spec.Parameters, err)
return err
}
}
createReq := &brokerapi.CreateServiceInstanceRequest{
ServiceID: in.Spec.OSBServiceID,
PlanID: in.Spec.OSBPlanID,
Parameters: parameters,
}
_, err = client.CreateServiceInstance(in.Spec.OSBGUID, createReq)
return err
}
// GetAuthCredentialsFromBroker returns the auth credentials, if any,
// contained in the secret referenced in the Broker's AuthSecret field, or
// returns an error. If the AuthSecret field is nil, empty values are
// returned.
func GetAuthCredentialsFromBroker(client kubernetes.Interface, broker *servicecatalog.Broker) (username, password string, err error) {
if broker.Spec.AuthSecret == nil {
return "", "", nil
}
authSecret, err := client.Core().Secrets(broker.Spec.AuthSecret.Namespace).Get(broker.Spec.AuthSecret.Name)
if err != nil {
return "", "", err
}
usernameBytes, ok := authSecret.Data["username"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain username")
}
passwordBytes, ok := authSecret.Data["password"]
if !ok {
return "", "", fmt.Errorf("auth secret didn't contain password")
}
return string(usernameBytes), string(passwordBytes), nil
}
///////////////////////////////////////////////////////////////////////////////
// All the methods implementing the Handler interface go here for clarity sake.
///////////////////////////////////////////////////////////////////////////////
func (h *handler) CreateServiceInstance(in *servicecatalog.Instance) (*servicecatalog.Instance, error) {
serviceID, planID, planName, err := util.GetServicePlanInfo(
h.apiClient.ServiceClasses(),
in.Spec.ServiceClassName,
in.Spec.PlanName,
)
if err != nil {
glog.Errorf("Error fetching service ID: %v", err)
return nil, err
}
in.Spec.OSBServiceID = serviceID
in.Spec.OSBPlanID = planID
in.Spec.PlanName = planName
if in.Spec.OSBGUID == "" {
in.Spec.OSBGUID = uuid.NewV4().String()
}
glog.Infof("Instantiating service %s using service/plan %s : %s", in.Name, serviceID, planID)
err = h.createServiceInstance(in)
in.Status = servicecatalog.InstanceStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionProvisionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
in.Status.Conditions = []servicecatalog.InstanceCondition{
{
Type: servicecatalog.InstanceConditionReady,
Status: servicecatalog.ConditionTrue,
},
}
}
glog.Infof("Updating Service %s with State\n%v", in.Name, in.Status.Conditions[0].Type)
return h.apiClient.Instances(in.ObjectMeta.Namespace).Update(in)
}
// DeleteServiceBinding executes all the actions needed before a binding resource can be
// safely deleted. These actions include but are not necessarily limited to deleting the
// kubernetes resources associated with the binding and calling the unbind REST operation
// on the backing OSB API
func (h *handler) DeleteServiceBinding(sb *servicecatalog.Binding) error {
// this logic to set and update the timestamp is TPR specific. to be moved to the API server
dts := metav1.Now()
sb.DeletionTimestamp = &dts
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// uninject
if err := h.injector.Uninject(sb); err != nil {
// if 0 conditions, uninject and drop condition for uninject
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// TODO: unbind && add conditions (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if err := h.unbind(sb); err != nil {
// TODO: add failure condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
// TODO: add success condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
if _, err := h.apiClient.Bindings(sb.Namespace).Update(sb); err != nil {
return err
}
// This is where the binding is _actually_ deleted after all necessary actions have been taken
if err := h.apiClient.Bindings(sb.Namespace).Delete(sb.Name); err != nil {
// TODO: add deletion error condition (https://github.com/kubernetes-incubator/service-catalog/issues/305)
return err
}
return nil
}
func (h *handler) CreateServiceBinding(in *servicecatalog.Binding) (*servicecatalog.Binding, error) {
glog.Infof("Creating Service Binding: %v", in)
inst, err := instanceForBinding(h.apiClient, in)
if err != nil {
return nil, err
}
sc, err := serviceClassForInstance(h.apiClient, inst)
if err != nil {
return nil, err
}
broker, err := brokerForServiceClass(h.apiClient, sc)
if err != nil {
return nil, err
}
authUsername, authPassword, err := GetAuthCredentialsFromBroker(h.k8sClient, broker)
if err != nil {
return nil, err
}
client := h.newClientFunc(broker.Name, broker.Spec.URL, authUsername, authPassword)
// Assign UUID to binding.
if in.Spec.OSBGUID == "" {
in.Spec.OSBGUID = uuid.NewV4().String()
}
parameters := make(map[string]interface{})
if in.Spec.Parameters != nil && len(in.Spec.Parameters.Raw) > 0 {
err = yaml.Unmarshal([]byte(in.Spec.Parameters.Raw), ¶meters)
if err != nil {
glog.Errorf("Failed to unmarshal Binding parameters\n%s\n %v", in.Spec.Parameters, err)
return nil, err
}
}
createReq := &brokerapi.BindingRequest{
ServiceID: inst.Spec.OSBServiceID,
PlanID: inst.Spec.OSBPlanID,
Parameters: parameters,
}
sbr, err := client.CreateServiceBinding(inst.Spec.OSBGUID, in.Spec.OSBGUID, createReq)
in.Status = servicecatalog.BindingStatus{}
if err != nil {
in.Status.Conditions = []servicecatalog.BindingCondition{
{
Type: servicecatalog.BindingConditionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
// Now try injection
err := h.injector.Inject(in, &sbr.Credentials)
if err != nil {
in.Status.Conditions = []servicecatalog.BindingCondition{
{
Type: servicecatalog.BindingConditionFailed,
Status: servicecatalog.ConditionTrue,
Reason: err.Error(),
},
}
glog.Errorf("Failed to create service instance: %v", err)
} else {
in.Status.Conditions = []servicecatalog.BindingCondition{
{
Type: servicecatalog.BindingConditionReady,
Status: servicecatalog.ConditionTrue,
},
}
}
}
glog.Infof("Updating Service Binding %s with State\n%v", in.Name, in.Status.Conditions[0].Type)
return h.apiClient.Bindings(in.ObjectMeta.Namespace).Update(in)
}
func (h *handler) | CreateServiceBroker | identifier_name |
|
Quirk.ts | } from "../Copy2Clipboard";
export abstract class Quirk {
static inputField: HTMLTextAreaElement;
static textFields: HTMLFieldSetElement;
private readonly name: string;
private shortName: string;
private id: string;
private readonly colorClass: string;
input: string;
private row: HTMLDivElement;
private textArea: HTMLTextAreaElement;
public activeCheckbox: HTMLInputElement;
optionalCheckboxes: Array<OptionalCheckbox>;
protected constructor(name: string, colorClass: string = "") {
this.name = name;
let spaceIndex = this.name.indexOf(" ");
this.shortName = spaceIndex > 0 ? this.name.substr(0, spaceIndex) : name;
this.id = this.shortName.toLocaleLowerCase();
this.optionalCheckboxes = new Array<OptionalCheckbox>();
this.colorClass = colorClass.length < 1 ? this.id : colorClass;
}
public render(category: Category): void {
Quirk.textFields.insertAdjacentHTML('beforeend', renderHTML(this.name, this.id, this.colorClass));
this.row = <HTMLTableRowElement>document.getElementById(this.id + "-row")
this.textArea = this.row.getElementsByTagName("textarea")[0];
this.textArea.onclick = selectAllAndCopy;
// Create toggle checkbox.
this.activeCheckbox = document.createElement("input");
this.activeCheckbox.classList.add("filled-in");
this.activeCheckbox.classList.add("checkbox-" + this.getColorClass());
this.activeCheckbox.type = "checkbox";
this.activeCheckbox.checked = true;
this.activeCheckbox.onchange = () => this.updateVisibility(category);
let td: HTMLTableCellElement = document.createElement("td");
td.insertAdjacentElement('beforeend', this.activeCheckbox);
// Checkbox requires a span element adjacent to it for Materialize's theme to work.
let span = document.createElement("span");
span.insertAdjacentText('beforeend', this.name);
td.insertAdjacentElement('beforeend', span);
let tr: HTMLTableRowElement = document.createElement("tr");
tr.classList.add("waves-effect");
tr.classList.add("waves-" + this.getColorClass());
tr.onclick = () => this.activeCheckbox.click();
tr.insertAdjacentElement('beforeend', td);
let toggleCheckboxSet = category.getMainCheckboxSetElement();
toggleCheckboxSet.insertAdjacentElement('beforeend', tr);
for (let i = 0; i < this.optionalCheckboxes.length; i++) {
this.optionalCheckboxes[i].render(category, this.getID(), this);
}
}
public getID(): string {
return this.id;
}
public | (bruh: string): void {
this.shortName = bruh;
this.id = bruh.toLocaleLowerCase();
}
public getShortName(): string {
return this.shortName;
}
public getColorClass(): string {
return this.colorClass;
}
public getTextAreaElement(): HTMLTextAreaElement {
return this.textArea;
}
updateVisibility(category: Category): void {
this.row.hidden = !this.activeCheckbox.checked;
let optionals = <HTMLCollectionOf<HTMLElement>>document.getElementsByClassName(this.id + "-optional");
for (let i = 0; i < optionals.length; i++) {
optionals[i].hidden = !this.activeCheckbox.checked;
}
let visible = !this.row.hidden
// Save setting to cookies.
setCookieBool(this.id, visible, 31);
let optionalCheckboxSet: HTMLDivElement = <HTMLDivElement>document.getElementById(category.tabName.toLocaleLowerCase() + "-optional-checkboxes");
if (visible) {
this.update(Quirk.inputField.value);
if (optionalCheckboxSet.hidden && optionals.length > 0) {
optionalCheckboxSet.hidden = false;
}
} else {
// Check if any other optional checkboxes are visible.
for (let i = 0; i < category.optionalCheckboxes.length; i++) {
if (!category.optionalCheckboxes[i].hidden) {
return;
}
}
// Hide the table.
optionalCheckboxSet.hidden = true;
}
}
update(str: string): void {
if (!this.activeCheckbox.checked || str.length < 1) { return; }
this.input = str;
this.quirkify();
this.updateTextField();
}
updateTextField(): void {
this.textArea.value = this.input;
// Auto resize.
Quirk.autoSize(this.textArea);
}
// Dynamically increase the height of a textarea.
static autoSize(element: HTMLTextAreaElement): void {
let minHeight: number = parseInt(window.getComputedStyle(element).getPropertyValue("min-height"));
element.style.height = "auto"; // Lets the element shrink size.
element.style.height = `${Math.max(minHeight, element.scrollHeight)}px`;
}
addCheckbox(label: string, title: string, defaultValue: boolean = false): OptionalCheckbox {
let checkbox: OptionalCheckbox = new OptionalCheckbox(label, title, defaultValue)
this.optionalCheckboxes.push(checkbox);
return checkbox;
}
abstract quirkify(): void;
protected lowerCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleLowerCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleLowerCase();
});
}
}
protected upperCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleUpperCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleUpperCase();
});
}
}
protected prefix(str: string): void {
this.input = str + this.input;
}
protected suffix(str: string): void {
this.input += str;
}
protected replaceString(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, replace);
}
protected replaceCaseInsensitive(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, replace);
}
protected replaceMatchCase(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return Quirk.matchCase(replace, match);
});
}
protected replaceWord(pattern: string, replace: string) {
this.replaceString("\\b" + pattern + "\\b", replace);
}
protected replaceWordMatchCase(pattern: string, replace: string) {
this.replaceMatchCase("\\b" + pattern + "\\b", replace);
}
// Function taken from https://stackoverflow.com/a/17265031/6446221.
private static matchCase(text: string, pattern: string): string {
// If the entire text is uppercase then uppercase the whole pattern regardless of lengths.
if (pattern.toUpperCase() === pattern) {
return text.toUpperCase();
}
let result = '';
for (let i = 0; i < text.length; i++) {
let c = text.charAt(i);
let p = pattern.charCodeAt(i);
if (p >= 65 && p < 65 + 26) {
result += c.toUpperCase();
} else {
result += c.toLowerCase();
}
}
return result;
}
randomReplace(pattern: string, replace: string, prob: number): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, function(match) {
if (Math.random() <= prob) {
return replace;
}
return match;
});
}
// Troll-specific stuff below.
// $1 - capture group for eyes.
// $2 - capture group for mouth.
replaceEmotes(replace: string): void {
let eyes = "[:;]";
let mouth = "[\\)\\(Dd]";
this.upperCase(`(${eyes})(${mouth})`);
let reg: RegExp = new RegExp(`(${eyes})(${mouth})`, "gi");
this.input = this.input.replace(reg, replace);
}
applyCatPuns(): void {
this.replaceMatchCase("mother", "meowther");
this.replaceMatchCase("for", "fur");
this.replaceMatchCase("pause", "paws");
this.replaceMatchCase("cause", "claws");
this.replaceMatchCase("now", "meow");
this.replaceMatchCase("(per|pre)", "pur");
}
applyFishPuns(): void {
this.replaceMatchCase("kill", "krill");
this.replaceMatchCase("well", "whale");
this.replaceMatchCase("fine", "fin");
this.replaceMatchCase("see", "sea");
this.replaceMatchCase("should", "shoald");
this.replaceMatchCase("kid", "squid");
this.replaceMatchCase("sure", "shore");
this.replaceMatchCase("crap", "carp");
this.replaceMatchCase("(what are|what do)", "water");
}
applyTiaraEmotes(): void {
this.replaceEmotes("38$2");
}
censorSwears(extreme: boolean = false): void {
this.replaceWordMatchCase("fuck", "f*ck");
| setShortName | identifier_name |
Quirk.ts | from "../Copy2Clipboard";
export abstract class Quirk {
static inputField: HTMLTextAreaElement;
static textFields: HTMLFieldSetElement;
private readonly name: string;
private shortName: string;
private id: string;
private readonly colorClass: string;
input: string;
private row: HTMLDivElement;
private textArea: HTMLTextAreaElement;
public activeCheckbox: HTMLInputElement;
optionalCheckboxes: Array<OptionalCheckbox>;
protected constructor(name: string, colorClass: string = "") {
this.name = name;
let spaceIndex = this.name.indexOf(" ");
this.shortName = spaceIndex > 0 ? this.name.substr(0, spaceIndex) : name;
this.id = this.shortName.toLocaleLowerCase();
this.optionalCheckboxes = new Array<OptionalCheckbox>();
this.colorClass = colorClass.length < 1 ? this.id : colorClass;
}
public render(category: Category): void {
Quirk.textFields.insertAdjacentHTML('beforeend', renderHTML(this.name, this.id, this.colorClass));
this.row = <HTMLTableRowElement>document.getElementById(this.id + "-row")
this.textArea = this.row.getElementsByTagName("textarea")[0];
this.textArea.onclick = selectAllAndCopy;
// Create toggle checkbox.
this.activeCheckbox = document.createElement("input");
this.activeCheckbox.classList.add("filled-in");
this.activeCheckbox.classList.add("checkbox-" + this.getColorClass());
this.activeCheckbox.type = "checkbox";
this.activeCheckbox.checked = true;
this.activeCheckbox.onchange = () => this.updateVisibility(category);
let td: HTMLTableCellElement = document.createElement("td");
td.insertAdjacentElement('beforeend', this.activeCheckbox);
// Checkbox requires a span element adjacent to it for Materialize's theme to work.
let span = document.createElement("span");
span.insertAdjacentText('beforeend', this.name);
td.insertAdjacentElement('beforeend', span);
let tr: HTMLTableRowElement = document.createElement("tr");
tr.classList.add("waves-effect");
tr.classList.add("waves-" + this.getColorClass());
tr.onclick = () => this.activeCheckbox.click();
tr.insertAdjacentElement('beforeend', td);
let toggleCheckboxSet = category.getMainCheckboxSetElement();
toggleCheckboxSet.insertAdjacentElement('beforeend', tr);
for (let i = 0; i < this.optionalCheckboxes.length; i++) {
this.optionalCheckboxes[i].render(category, this.getID(), this);
}
}
public getID(): string {
return this.id;
}
public setShortName(bruh: string): void {
this.shortName = bruh;
this.id = bruh.toLocaleLowerCase();
}
public getShortName(): string {
return this.shortName;
}
public getColorClass(): string {
return this.colorClass;
}
public getTextAreaElement(): HTMLTextAreaElement {
return this.textArea;
}
updateVisibility(category: Category): void {
this.row.hidden = !this.activeCheckbox.checked;
let optionals = <HTMLCollectionOf<HTMLElement>>document.getElementsByClassName(this.id + "-optional");
for (let i = 0; i < optionals.length; i++) {
optionals[i].hidden = !this.activeCheckbox.checked;
}
let visible = !this.row.hidden
// Save setting to cookies.
setCookieBool(this.id, visible, 31);
let optionalCheckboxSet: HTMLDivElement = <HTMLDivElement>document.getElementById(category.tabName.toLocaleLowerCase() + "-optional-checkboxes");
if (visible) {
this.update(Quirk.inputField.value);
if (optionalCheckboxSet.hidden && optionals.length > 0) {
optionalCheckboxSet.hidden = false;
}
} else {
// Check if any other optional checkboxes are visible.
for (let i = 0; i < category.optionalCheckboxes.length; i++) {
if (!category.optionalCheckboxes[i].hidden) {
return;
}
}
// Hide the table.
optionalCheckboxSet.hidden = true;
}
}
update(str: string): void {
if (!this.activeCheckbox.checked || str.length < 1) { return; }
this.input = str;
this.quirkify();
this.updateTextField();
}
updateTextField(): void |
// Dynamically increase the height of a textarea.
static autoSize(element: HTMLTextAreaElement): void {
let minHeight: number = parseInt(window.getComputedStyle(element).getPropertyValue("min-height"));
element.style.height = "auto"; // Lets the element shrink size.
element.style.height = `${Math.max(minHeight, element.scrollHeight)}px`;
}
addCheckbox(label: string, title: string, defaultValue: boolean = false): OptionalCheckbox {
let checkbox: OptionalCheckbox = new OptionalCheckbox(label, title, defaultValue)
this.optionalCheckboxes.push(checkbox);
return checkbox;
}
abstract quirkify(): void;
protected lowerCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleLowerCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleLowerCase();
});
}
}
protected upperCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleUpperCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleUpperCase();
});
}
}
protected prefix(str: string): void {
this.input = str + this.input;
}
protected suffix(str: string): void {
this.input += str;
}
protected replaceString(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, replace);
}
protected replaceCaseInsensitive(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, replace);
}
protected replaceMatchCase(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return Quirk.matchCase(replace, match);
});
}
protected replaceWord(pattern: string, replace: string) {
this.replaceString("\\b" + pattern + "\\b", replace);
}
protected replaceWordMatchCase(pattern: string, replace: string) {
this.replaceMatchCase("\\b" + pattern + "\\b", replace);
}
// Function taken from https://stackoverflow.com/a/17265031/6446221.
private static matchCase(text: string, pattern: string): string {
// If the entire text is uppercase then uppercase the whole pattern regardless of lengths.
if (pattern.toUpperCase() === pattern) {
return text.toUpperCase();
}
let result = '';
for (let i = 0; i < text.length; i++) {
let c = text.charAt(i);
let p = pattern.charCodeAt(i);
if (p >= 65 && p < 65 + 26) {
result += c.toUpperCase();
} else {
result += c.toLowerCase();
}
}
return result;
}
randomReplace(pattern: string, replace: string, prob: number): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, function(match) {
if (Math.random() <= prob) {
return replace;
}
return match;
});
}
// Troll-specific stuff below.
// $1 - capture group for eyes.
// $2 - capture group for mouth.
replaceEmotes(replace: string): void {
let eyes = "[:;]";
let mouth = "[\\)\\(Dd]";
this.upperCase(`(${eyes})(${mouth})`);
let reg: RegExp = new RegExp(`(${eyes})(${mouth})`, "gi");
this.input = this.input.replace(reg, replace);
}
applyCatPuns(): void {
this.replaceMatchCase("mother", "meowther");
this.replaceMatchCase("for", "fur");
this.replaceMatchCase("pause", "paws");
this.replaceMatchCase("cause", "claws");
this.replaceMatchCase("now", "meow");
this.replaceMatchCase("(per|pre)", "pur");
}
applyFishPuns(): void {
this.replaceMatchCase("kill", "krill");
this.replaceMatchCase("well", "whale");
this.replaceMatchCase("fine", "fin");
this.replaceMatchCase("see", "sea");
this.replaceMatchCase("should", "shoald");
this.replaceMatchCase("kid", "squid");
this.replaceMatchCase("sure", "shore");
this.replaceMatchCase("crap", "carp");
this.replaceMatchCase("(what are|what do)", "water");
}
applyTiaraEmotes(): void {
this.replaceEmotes("38$2");
}
censorSwears(extreme: boolean = false): void {
this.replaceWordMatchCase("fuck", "f*ck");
| {
this.textArea.value = this.input;
// Auto resize.
Quirk.autoSize(this.textArea);
} | identifier_body |
Quirk.ts | from "../Copy2Clipboard";
export abstract class Quirk {
static inputField: HTMLTextAreaElement;
static textFields: HTMLFieldSetElement;
private readonly name: string;
private shortName: string;
private id: string;
private readonly colorClass: string;
input: string;
private row: HTMLDivElement;
private textArea: HTMLTextAreaElement;
public activeCheckbox: HTMLInputElement;
optionalCheckboxes: Array<OptionalCheckbox>;
protected constructor(name: string, colorClass: string = "") {
this.name = name;
let spaceIndex = this.name.indexOf(" ");
this.shortName = spaceIndex > 0 ? this.name.substr(0, spaceIndex) : name;
this.id = this.shortName.toLocaleLowerCase();
this.optionalCheckboxes = new Array<OptionalCheckbox>();
this.colorClass = colorClass.length < 1 ? this.id : colorClass;
}
public render(category: Category): void {
Quirk.textFields.insertAdjacentHTML('beforeend', renderHTML(this.name, this.id, this.colorClass));
this.row = <HTMLTableRowElement>document.getElementById(this.id + "-row")
this.textArea = this.row.getElementsByTagName("textarea")[0];
this.textArea.onclick = selectAllAndCopy;
// Create toggle checkbox.
this.activeCheckbox = document.createElement("input");
this.activeCheckbox.classList.add("filled-in");
this.activeCheckbox.classList.add("checkbox-" + this.getColorClass());
this.activeCheckbox.type = "checkbox";
this.activeCheckbox.checked = true;
this.activeCheckbox.onchange = () => this.updateVisibility(category);
let td: HTMLTableCellElement = document.createElement("td");
td.insertAdjacentElement('beforeend', this.activeCheckbox);
// Checkbox requires a span element adjacent to it for Materialize's theme to work.
let span = document.createElement("span");
span.insertAdjacentText('beforeend', this.name);
td.insertAdjacentElement('beforeend', span);
let tr: HTMLTableRowElement = document.createElement("tr");
tr.classList.add("waves-effect");
tr.classList.add("waves-" + this.getColorClass());
tr.onclick = () => this.activeCheckbox.click();
tr.insertAdjacentElement('beforeend', td);
let toggleCheckboxSet = category.getMainCheckboxSetElement();
toggleCheckboxSet.insertAdjacentElement('beforeend', tr);
for (let i = 0; i < this.optionalCheckboxes.length; i++) {
this.optionalCheckboxes[i].render(category, this.getID(), this);
}
}
public getID(): string {
return this.id;
}
public setShortName(bruh: string): void {
this.shortName = bruh;
this.id = bruh.toLocaleLowerCase();
}
public getShortName(): string {
return this.shortName;
}
public getColorClass(): string {
return this.colorClass;
}
public getTextAreaElement(): HTMLTextAreaElement {
return this.textArea;
}
updateVisibility(category: Category): void {
this.row.hidden = !this.activeCheckbox.checked;
let optionals = <HTMLCollectionOf<HTMLElement>>document.getElementsByClassName(this.id + "-optional");
for (let i = 0; i < optionals.length; i++) {
optionals[i].hidden = !this.activeCheckbox.checked;
}
let visible = !this.row.hidden
// Save setting to cookies.
setCookieBool(this.id, visible, 31);
let optionalCheckboxSet: HTMLDivElement = <HTMLDivElement>document.getElementById(category.tabName.toLocaleLowerCase() + "-optional-checkboxes");
if (visible) {
this.update(Quirk.inputField.value);
if (optionalCheckboxSet.hidden && optionals.length > 0) {
optionalCheckboxSet.hidden = false;
}
} else {
// Check if any other optional checkboxes are visible.
for (let i = 0; i < category.optionalCheckboxes.length; i++) {
if (!category.optionalCheckboxes[i].hidden) {
return;
}
}
// Hide the table.
optionalCheckboxSet.hidden = true;
}
}
update(str: string): void {
if (!this.activeCheckbox.checked || str.length < 1) { return; }
this.input = str;
this.quirkify();
this.updateTextField();
}
updateTextField(): void {
this.textArea.value = this.input;
// Auto resize.
Quirk.autoSize(this.textArea);
}
// Dynamically increase the height of a textarea.
static autoSize(element: HTMLTextAreaElement): void {
let minHeight: number = parseInt(window.getComputedStyle(element).getPropertyValue("min-height"));
element.style.height = "auto"; // Lets the element shrink size.
element.style.height = `${Math.max(minHeight, element.scrollHeight)}px`;
}
addCheckbox(label: string, title: string, defaultValue: boolean = false): OptionalCheckbox {
let checkbox: OptionalCheckbox = new OptionalCheckbox(label, title, defaultValue)
this.optionalCheckboxes.push(checkbox);
return checkbox;
}
abstract quirkify(): void;
protected lowerCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleLowerCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleLowerCase();
});
}
}
protected upperCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleUpperCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleUpperCase();
});
}
}
protected prefix(str: string): void {
this.input = str + this.input;
}
protected suffix(str: string): void {
this.input += str;
}
protected replaceString(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, replace);
}
protected replaceCaseInsensitive(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, replace);
}
protected replaceMatchCase(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return Quirk.matchCase(replace, match);
});
}
protected replaceWord(pattern: string, replace: string) {
this.replaceString("\\b" + pattern + "\\b", replace);
}
protected replaceWordMatchCase(pattern: string, replace: string) {
this.replaceMatchCase("\\b" + pattern + "\\b", replace);
}
// Function taken from https://stackoverflow.com/a/17265031/6446221.
private static matchCase(text: string, pattern: string): string {
// If the entire text is uppercase then uppercase the whole pattern regardless of lengths.
if (pattern.toUpperCase() === pattern) {
return text.toUpperCase();
}
let result = '';
for (let i = 0; i < text.length; i++) {
let c = text.charAt(i);
let p = pattern.charCodeAt(i);
if (p >= 65 && p < 65 + 26) {
result += c.toUpperCase();
} else {
result += c.toLowerCase();
}
}
return result;
}
randomReplace(pattern: string, replace: string, prob: number): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, function(match) {
if (Math.random() <= prob) {
return replace;
}
return match;
});
}
// Troll-specific stuff below.
// $1 - capture group for eyes.
// $2 - capture group for mouth.
replaceEmotes(replace: string): void {
let eyes = "[:;]";
let mouth = "[\\)\\(Dd]";
this.upperCase(`(${eyes})(${mouth})`);
let reg: RegExp = new RegExp(`(${eyes})(${mouth})`, "gi");
this.input = this.input.replace(reg, replace);
}
applyCatPuns(): void {
this.replaceMatchCase("mother", "meowther");
this.replaceMatchCase("for", "fur");
this.replaceMatchCase("pause", "paws"); | this.replaceMatchCase("now", "meow");
this.replaceMatchCase("(per|pre)", "pur");
}
applyFishPuns(): void {
this.replaceMatchCase("kill", "krill");
this.replaceMatchCase("well", "whale");
this.replaceMatchCase("fine", "fin");
this.replaceMatchCase("see", "sea");
this.replaceMatchCase("should", "shoald");
this.replaceMatchCase("kid", "squid");
this.replaceMatchCase("sure", "shore");
this.replaceMatchCase("crap", "carp");
this.replaceMatchCase("(what are|what do)", "water");
}
applyTiaraEmotes(): void {
this.replaceEmotes("38$2");
}
censorSwears(extreme: boolean = false): void {
this.replaceWordMatchCase("fuck", "f*ck");
this | this.replaceMatchCase("cause", "claws"); | random_line_split |
Quirk.ts | from "../Copy2Clipboard";
export abstract class Quirk {
static inputField: HTMLTextAreaElement;
static textFields: HTMLFieldSetElement;
private readonly name: string;
private shortName: string;
private id: string;
private readonly colorClass: string;
input: string;
private row: HTMLDivElement;
private textArea: HTMLTextAreaElement;
public activeCheckbox: HTMLInputElement;
optionalCheckboxes: Array<OptionalCheckbox>;
protected constructor(name: string, colorClass: string = "") {
this.name = name;
let spaceIndex = this.name.indexOf(" ");
this.shortName = spaceIndex > 0 ? this.name.substr(0, spaceIndex) : name;
this.id = this.shortName.toLocaleLowerCase();
this.optionalCheckboxes = new Array<OptionalCheckbox>();
this.colorClass = colorClass.length < 1 ? this.id : colorClass;
}
public render(category: Category): void {
Quirk.textFields.insertAdjacentHTML('beforeend', renderHTML(this.name, this.id, this.colorClass));
this.row = <HTMLTableRowElement>document.getElementById(this.id + "-row")
this.textArea = this.row.getElementsByTagName("textarea")[0];
this.textArea.onclick = selectAllAndCopy;
// Create toggle checkbox.
this.activeCheckbox = document.createElement("input");
this.activeCheckbox.classList.add("filled-in");
this.activeCheckbox.classList.add("checkbox-" + this.getColorClass());
this.activeCheckbox.type = "checkbox";
this.activeCheckbox.checked = true;
this.activeCheckbox.onchange = () => this.updateVisibility(category);
let td: HTMLTableCellElement = document.createElement("td");
td.insertAdjacentElement('beforeend', this.activeCheckbox);
// Checkbox requires a span element adjacent to it for Materialize's theme to work.
let span = document.createElement("span");
span.insertAdjacentText('beforeend', this.name);
td.insertAdjacentElement('beforeend', span);
let tr: HTMLTableRowElement = document.createElement("tr");
tr.classList.add("waves-effect");
tr.classList.add("waves-" + this.getColorClass());
tr.onclick = () => this.activeCheckbox.click();
tr.insertAdjacentElement('beforeend', td);
let toggleCheckboxSet = category.getMainCheckboxSetElement();
toggleCheckboxSet.insertAdjacentElement('beforeend', tr);
for (let i = 0; i < this.optionalCheckboxes.length; i++) {
this.optionalCheckboxes[i].render(category, this.getID(), this);
}
}
public getID(): string {
return this.id;
}
public setShortName(bruh: string): void {
this.shortName = bruh;
this.id = bruh.toLocaleLowerCase();
}
public getShortName(): string {
return this.shortName;
}
public getColorClass(): string {
return this.colorClass;
}
public getTextAreaElement(): HTMLTextAreaElement {
return this.textArea;
}
updateVisibility(category: Category): void {
this.row.hidden = !this.activeCheckbox.checked;
let optionals = <HTMLCollectionOf<HTMLElement>>document.getElementsByClassName(this.id + "-optional");
for (let i = 0; i < optionals.length; i++) |
let visible = !this.row.hidden
// Save setting to cookies.
setCookieBool(this.id, visible, 31);
let optionalCheckboxSet: HTMLDivElement = <HTMLDivElement>document.getElementById(category.tabName.toLocaleLowerCase() + "-optional-checkboxes");
if (visible) {
this.update(Quirk.inputField.value);
if (optionalCheckboxSet.hidden && optionals.length > 0) {
optionalCheckboxSet.hidden = false;
}
} else {
// Check if any other optional checkboxes are visible.
for (let i = 0; i < category.optionalCheckboxes.length; i++) {
if (!category.optionalCheckboxes[i].hidden) {
return;
}
}
// Hide the table.
optionalCheckboxSet.hidden = true;
}
}
update(str: string): void {
if (!this.activeCheckbox.checked || str.length < 1) { return; }
this.input = str;
this.quirkify();
this.updateTextField();
}
updateTextField(): void {
this.textArea.value = this.input;
// Auto resize.
Quirk.autoSize(this.textArea);
}
// Dynamically increase the height of a textarea.
static autoSize(element: HTMLTextAreaElement): void {
let minHeight: number = parseInt(window.getComputedStyle(element).getPropertyValue("min-height"));
element.style.height = "auto"; // Lets the element shrink size.
element.style.height = `${Math.max(minHeight, element.scrollHeight)}px`;
}
addCheckbox(label: string, title: string, defaultValue: boolean = false): OptionalCheckbox {
let checkbox: OptionalCheckbox = new OptionalCheckbox(label, title, defaultValue)
this.optionalCheckboxes.push(checkbox);
return checkbox;
}
abstract quirkify(): void;
protected lowerCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleLowerCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleLowerCase();
});
}
}
protected upperCase(pattern: string = ""): void {
if (pattern.length < 1) {
this.input = this.input.toLocaleUpperCase();
} else {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return match.toLocaleUpperCase();
});
}
}
protected prefix(str: string): void {
this.input = str + this.input;
}
protected suffix(str: string): void {
this.input += str;
}
protected replaceString(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, replace);
}
protected replaceCaseInsensitive(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, replace);
}
protected replaceMatchCase(pattern: string, replace: string): void {
let reg: RegExp = new RegExp(pattern, "gi");
this.input = this.input.replace(reg, function(match) {
return Quirk.matchCase(replace, match);
});
}
protected replaceWord(pattern: string, replace: string) {
this.replaceString("\\b" + pattern + "\\b", replace);
}
protected replaceWordMatchCase(pattern: string, replace: string) {
this.replaceMatchCase("\\b" + pattern + "\\b", replace);
}
// Function taken from https://stackoverflow.com/a/17265031/6446221.
private static matchCase(text: string, pattern: string): string {
// If the entire text is uppercase then uppercase the whole pattern regardless of lengths.
if (pattern.toUpperCase() === pattern) {
return text.toUpperCase();
}
let result = '';
for (let i = 0; i < text.length; i++) {
let c = text.charAt(i);
let p = pattern.charCodeAt(i);
if (p >= 65 && p < 65 + 26) {
result += c.toUpperCase();
} else {
result += c.toLowerCase();
}
}
return result;
}
randomReplace(pattern: string, replace: string, prob: number): void {
let reg: RegExp = new RegExp(pattern, "g");
this.input = this.input.replace(reg, function(match) {
if (Math.random() <= prob) {
return replace;
}
return match;
});
}
// Troll-specific stuff below.
// $1 - capture group for eyes.
// $2 - capture group for mouth.
replaceEmotes(replace: string): void {
let eyes = "[:;]";
let mouth = "[\\)\\(Dd]";
this.upperCase(`(${eyes})(${mouth})`);
let reg: RegExp = new RegExp(`(${eyes})(${mouth})`, "gi");
this.input = this.input.replace(reg, replace);
}
applyCatPuns(): void {
this.replaceMatchCase("mother", "meowther");
this.replaceMatchCase("for", "fur");
this.replaceMatchCase("pause", "paws");
this.replaceMatchCase("cause", "claws");
this.replaceMatchCase("now", "meow");
this.replaceMatchCase("(per|pre)", "pur");
}
applyFishPuns(): void {
this.replaceMatchCase("kill", "krill");
this.replaceMatchCase("well", "whale");
this.replaceMatchCase("fine", "fin");
this.replaceMatchCase("see", "sea");
this.replaceMatchCase("should", "shoald");
this.replaceMatchCase("kid", "squid");
this.replaceMatchCase("sure", "shore");
this.replaceMatchCase("crap", "carp");
this.replaceMatchCase("(what are|what do)", "water");
}
applyTiaraEmotes(): void {
this.replaceEmotes("38$2");
}
censorSwears(extreme: boolean = false): void {
this.replaceWordMatchCase("fuck", "f*ck");
| {
optionals[i].hidden = !this.activeCheckbox.checked;
} | conditional_block |
main.py | "cpc": "$CPC$",
"pcc": "$PCC$",
"drfc": "$D-RFC$",
"wpc": "$WPC$"
})
df_eval["Critic"] = df_eval["Critic"].replace(
to_replace={
"concat": "MLP",
"separable": "Separable",
"innerprod": "Inner product",
"bilinear": "Bilinear"
})
return df_eval
def apply_default_style(ax):
ax.set_xlim([0, 20001])
ax.get_xaxis().set_major_formatter(
FuncFormatter(lambda x, p: format(int(x/1000), ',')))
ax.set_xlabel("Training steps (in thousands)")
plt.tick_params(top=False, right=False, bottom=False, left=False)
handles, labels = ax.get_legend_handles_labels()
plt.legend(loc="lower right", handles=handles[1:], labels=labels[1:])
def get_testing_loss(x_array, session, loss, data_ph, dims, batch_size=512):
total_loss = 0
for i in range(0, x_array.shape[0], batch_size):
x_slice = x_array[i:i+batch_size, :dims]
total_loss += x_slice.shape[0] * session.run(loss,
feed_dict={data_ph: x_slice})
return total_loss / x_array.shape[0]
def get_classification_accuracy(session, codes, data_ph, dims):
x_train_mapped = map_data(x_train, session, codes, data_ph, dims)
x_test_mapped = map_data(x_test, session, codes, data_ph, dims)
accuracy = logistic_fit(x_train_mapped, y_train, x_test_mapped, y_test)
return accuracy
def map_data(x_array, session, codes, data_ph, dims, batch_size=512):
x_mapped = []
for i in range(0, x_array.shape[0], batch_size):
x_mapped.append(
session.run(codes,
feed_dict={data_ph: x_array[i:i+batch_size, :dims]}))
return np.concatenate(x_mapped, axis=0)
def reduce_logmeanexp_nodiag(x, axis=None):
batch_size = x.shape[0]
logsumexp = tf.reduce_logsumexp(input_tensor=x - tf.linalg.tensor_diag(np.inf * tf.ones(batch_size)), axis=axis)
if axis:
num_elem = batch_size - 1.
else:
num_elem = batch_size * (batch_size - 1.)
return logsumexp - tf.math.log(num_elem)
def tuba_lower_bound(scores, log_baseline=None):
if log_baseline is not None:
scores -= log_baseline[:, None]
batch_size = tf.cast(scores.shape[0], tf.float32)
# First term is an expectation over samples from the joint,
# which are the diagonal elmements of the scores matrix.
joint_term = tf.reduce_mean(input_tensor=tf.linalg.diag_part(scores))
# Second term is an expectation over samples from the marginal,
# which are the off-diagonal elements of the scores matrix.
marg_term = tf.exp(reduce_logmeanexp_nodiag(scores))
return 1. + joint_term - marg_term
def nwj_lower_bound(scores):
# equivalent to: tuba_lower_bound(scores, log_baseline=1.)
return tuba_lower_bound(scores - 1.)
@tf.function
def js_fgan_lower_bound(f):
"""Lower bound on Jensen-Shannon divergence from Nowozin et al. (2016)."""
f_diag = tf.linalg.tensor_diag_part(f)
first_term = tf.reduce_mean(-tf.nn.softplus(-f_diag))
n = tf.cast(f.shape[0], tf.float32)
second_term = (tf.reduce_sum(tf.nn.softplus(f)) - tf.reduce_sum(tf.nn.softplus(f_diag))) / (n * (n - 1.))
return first_term - second_term
@tf.function
def infonce_lower_bound(scores):
"""InfoNCE lower bound from van den Oord et al. (2018)."""
nll = tf.reduce_mean(input_tensor=tf.linalg.diag_part(scores) - tf.reduce_logsumexp(input_tensor=scores, axis=1))
mi = tf.math.log(tf.cast(scores.shape[0], tf.float32)) + nll
return mi
@tf.function
def our_lower_bound(scores):
# scores: 128, 128
"""Our lower bound"""
batch_size = tf.cast(scores.shape[0], tf.float32)
joint_term = tf.reduce_mean(input_tensor=tf.linalg.diag_part(scores))
# expectation
scores_sq = scores**2
marg_num = batch_size * (batch_size - 1.)
marg_term = tf.reduce_sum(input_tensor=scores_sq) - tf.reduce_sum(input_tensor=tf.linalg.diag_part(scores_sq))
marg_term = marg_term / marg_num
# tf.print(joint_term - 0.5*marg_term)
return joint_term - 0.5*marg_term
# nll = tf.reduce_mean(tf.linalg.diag_part(scores) - 0.5 * tf.math.reduce_euclidean_norm(scores, axis=1))
# tf.print(nll)
# mi = tf.math.log(tf.cast(scores.shape[0].value, tf.float32)) + nll
# return mi
@tf.function
def skew_js_fgan_lower_bound(f):
"""skewed js lower bound (true cross entropy)"""
n = tf.cast(f.shape[0], tf.float32)
alpha = 1/n
f_diag = tf.linalg.tensor_diag_part(f)
first_term = tf.reduce_mean(-tf.nn.softplus(-f_diag))
second_term = (tf.reduce_sum(tf.nn.softplus(f)) - tf.reduce_sum(tf.nn.softplus(f_diag))) / (n * (n - 1.))
return alpha*first_term - (1-alpha)*second_term
@tf.function
def label_smooth_pcc(f):
""" pcc with label smoothing trick"""
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
@tf.function
def predict_smooth_pcc(f):
""" pcc with predictor smoothing trick"""
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
pre_prob = (1.0 - args.smoothing) * pre_prob + args.smoothing / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
@tf.function
def adap_label_smooth_pcc(f):
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
alpha = acti_func(pre_prob, a, b, c)
new_labels = (1.0 - alpha) * labels + alpha / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(new_labels, pre_prob)
@tf.function
def adap_pred_smooth_pcc(f):
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
# print('pre_prob:',pre_prob)
alpha = acti_func(pre_prob, a, b, c)
pre_prob = (1.0 - alpha) * pre_prob + alpha / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
# @title Define the linear evaluation protocol { display-mode: "form" }
def logistic_fit(x_train, y_train, x_test, y_test):
logistic_regressor = sk_linear.LogisticRegression(
solver='saga', multi_class='multinomial', tol=.1, C=10.)
from sklearn.preprocessing import MinMaxScaler
scaler = Min | """Convert results class to a data frame."""
label = "{}, {}, {}".format(nets, critic, loss)
rows = list(
zip(
itertools.repeat(exp_name),
itertools.repeat(nets),
itertools.repeat(critic),
itertools.repeat(loss),
itertools.repeat(seed),
result.iterations,
[-loss for loss in result.testing_losses], # Loss -> bound.
result.classification_accuracies,
itertools.repeat(label)))
df_eval = pd.DataFrame(
rows,
columns=("exp_name", "nets", "Critic", "Estimator",
"run", "iteration", "bound_value", "accuracy", "label"))
df_eval["Estimator"] = df_eval["Estimator"].replace(
to_replace={ | identifier_body |
|
main.py |
def skew_js_fgan_lower_bound(f):
"""skewed js lower bound (true cross entropy)"""
n = tf.cast(f.shape[0], tf.float32)
alpha = 1/n
f_diag = tf.linalg.tensor_diag_part(f)
first_term = tf.reduce_mean(-tf.nn.softplus(-f_diag))
second_term = (tf.reduce_sum(tf.nn.softplus(f)) - tf.reduce_sum(tf.nn.softplus(f_diag))) / (n * (n - 1.))
return alpha*first_term - (1-alpha)*second_term
@tf.function
def label_smooth_pcc(f):
""" pcc with label smoothing trick"""
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
@tf.function
def predict_smooth_pcc(f):
""" pcc with predictor smoothing trick"""
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
pre_prob = (1.0 - args.smoothing) * pre_prob + args.smoothing / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
@tf.function
def adap_label_smooth_pcc(f):
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
alpha = acti_func(pre_prob, a, b, c)
new_labels = (1.0 - alpha) * labels + alpha / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(new_labels, pre_prob)
@tf.function
def adap_pred_smooth_pcc(f):
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
# print('pre_prob:',pre_prob)
alpha = acti_func(pre_prob, a, b, c)
pre_prob = (1.0 - alpha) * pre_prob + alpha / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
# @title Define the linear evaluation protocol { display-mode: "form" }
def logistic_fit(x_train, y_train, x_test, y_test):
logistic_regressor = sk_linear.LogisticRegression(
solver='saga', multi_class='multinomial', tol=.1, C=10.)
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
logistic_regressor.fit(x_train, y_train.ravel())
return logistic_regressor.score(x_test, y_test.ravel())
# @title Define and load the dataset, check baseline in pixel space { display-mode: "form" }
tf.compat.v1.reset_default_graph()
def map_fn(example):
image = example[FEATURE_INPUT]
image = tf.cast(image, tf.float32) / 255.0
image = tf.reshape(image, [-1]) # Flatten.
label = example[FEATURE_LABEL]
return {FEATURE_INPUT: image, FEATURE_LABEL: label}
def load_data(split):
return (tfds.load(TFDS_NAME, data_dir='/public/wangxu/data/', split=split)
.cache()
.map(map_func=map_fn)
.shuffle(1000))
def tfds_to_np(dataset):
features = list(tfds.as_numpy(dataset))
images = np.stack([f[FEATURE_INPUT].ravel() for f in features])
labels = np.stack([f[FEATURE_LABEL].ravel() for f in features])
return images, labels
dataset_train = load_data("train")
dataset_test = load_data("test")
x_train, y_train = tfds_to_np(dataset_train)
x_test, y_test = tfds_to_np(dataset_test)
tf.compat.v1.reset_default_graph()
x_train_noisy = x_train + 0.05 * np.random.randn(*x_train.shape)
x_test_noisy = x_test + 0.05 * np.random.randn(*x_test.shape)
print("Fit on half the pixels: {}. It should be around 0.835.".format(
logistic_fit(x_train_noisy[:, :DIMS//2], y_train,
x_test_noisy[:, :DIMS//2], y_test)))
def processed_train_data(dims, batch_size):
dataset = load_data("train")
dataset_batched = dataset.repeat().batch(batch_size, drop_remainder=True)
get_next = tf.compat.v1.data.make_one_shot_iterator(dataset_batched).get_next()
features = get_next[FEATURE_INPUT]
labels = get_next[FEATURE_LABEL]
# Martin: where the problem occurs
x_1, x_2 = tf.split(features, [dims, DIMS-dims], axis=-1)
return x_1, x_2, labels
class MLP(tf.keras.Model):
def __init__(self, layer_dimensions, shortcuts, dense_kwargs={}):
super(MLP, self).__init__()
self._layers = [tfkl.Dense(dimensions, **dense_kwargs)
for dimensions in layer_dimensions[:-1]]
dense_kwargs_copy = copy.deepcopy(dense_kwargs)
dense_kwargs_copy["activation"] = None
self._layers.append(tfkl.Dense(layer_dimensions[-1], **dense_kwargs_copy))
self._shortcuts = shortcuts
@property
def layers(self):
return self._layers
def __call__(self, inputs):
x = inputs
for layer in self.layers:
x = layer(x) + x if self._shortcuts else layer(x)
return x
# LayerNorm implementation copied from
# https://stackoverflow.com/questions/39095252/fail-to-implement-layer-normalization-with-keras
class LayerNorm(tfkl.Layer):
""" Layer Normalization in the style of https://arxiv.org/abs/1607.06450 """
def __init__(self, scale_initializer='ones', bias_initializer='zeros',
axes=[1,2,3], epsilon=1e-6, **kwargs):
super(LayerNorm, self).__init__(**kwargs)
self.epsilon = epsilon
self.scale_initializer = tf.keras.initializers.get(scale_initializer)
self.bias_initializer = tf.keras.initializers.get(bias_initializer)
self.axes = axes
def build(self, input_shape):
self.scale = self.add_weight(shape=(input_shape[-1],),
initializer=self.scale_initializer,
trainable=True,
name='{}_scale'.format(self.name))
self.bias = self.add_weight(shape=(input_shape[-1],),
initializer=self.bias_initializer,
trainable=True,
name='{}_bias'.format(self.name))
self.built = True
def call(self, x, mask=None):
mean = tf.keras.backend.mean(x, axis=self.axes, keepdims=True)
std = tf.keras.backend.std(x, axis=self.axes, keepdims=True)
norm = (x - mean) * (1/(std + self.epsilon))
return norm * self.scale + self.bias
def compute_output_shape(self, input_shape):
return input_shape
class ConvNet(tf.keras.Sequential):
def __init__(self, channels=64, kernel_size=5, input_dim=DIMS//2, output_dim=100,
activation=tf.nn.relu):
# Note: This works only for the specific data set considered here.
super(ConvNet, self).__init__([
tfkl.Reshape((14, 28, 1), input_shape=(input_dim,)),
tfkl.Conv2D(channels, kernel_size, strides=2,
padding="same", activation=activation),
tfkl.Conv2D(2*channels, kernel_size, strides=2,
padding="same", activation=activation),
LayerNorm(),
tfkl.GlobalAveragePooling2D(),
tfkl.Dense(output_dim),
])
from tensorflow_probability.python.internal import tensorshape_util
import tensorflow.compat.v1 as tf1
from tensorflow_probability.python.bijectors import affine_scalar
from tensorflow_probability.python.bijectors import bijector as bijector_lib
# Modified from tensorflow_probability/python/bijectors/real_nvp.py
class RealNVP(bijector_lib.Bijector):
def __init__(self,
num_masked,
shift_and_log_scale_fn=None,
bijector_fn=None,
is_constant_jacobian=False,
validate_args=False,
name=None):
name = name or 'real_nvp'
if num_masked < 0:
| raise ValueError('num_masked must be a non-negative integer.') | conditional_block |
|
main.py | n - 1.))
return first_term - second_term
@tf.function
def infonce_lower_bound(scores):
"""InfoNCE lower bound from van den Oord et al. (2018)."""
nll = tf.reduce_mean(input_tensor=tf.linalg.diag_part(scores) - tf.reduce_logsumexp(input_tensor=scores, axis=1))
mi = tf.math.log(tf.cast(scores.shape[0], tf.float32)) + nll
return mi
@tf.function
def our_lower_bound(scores):
# scores: 128, 128
"""Our lower bound"""
batch_size = tf.cast(scores.shape[0], tf.float32)
joint_term = tf.reduce_mean(input_tensor=tf.linalg.diag_part(scores))
# expectation
scores_sq = scores**2
marg_num = batch_size * (batch_size - 1.)
marg_term = tf.reduce_sum(input_tensor=scores_sq) - tf.reduce_sum(input_tensor=tf.linalg.diag_part(scores_sq))
marg_term = marg_term / marg_num
# tf.print(joint_term - 0.5*marg_term)
return joint_term - 0.5*marg_term
# nll = tf.reduce_mean(tf.linalg.diag_part(scores) - 0.5 * tf.math.reduce_euclidean_norm(scores, axis=1))
# tf.print(nll)
# mi = tf.math.log(tf.cast(scores.shape[0].value, tf.float32)) + nll
# return mi
@tf.function
def skew_js_fgan_lower_bound(f):
"""skewed js lower bound (true cross entropy)"""
n = tf.cast(f.shape[0], tf.float32)
alpha = 1/n
f_diag = tf.linalg.tensor_diag_part(f)
first_term = tf.reduce_mean(-tf.nn.softplus(-f_diag))
second_term = (tf.reduce_sum(tf.nn.softplus(f)) - tf.reduce_sum(tf.nn.softplus(f_diag))) / (n * (n - 1.))
return alpha*first_term - (1-alpha)*second_term
@tf.function
def label_smooth_pcc(f):
""" pcc with label smoothing trick"""
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
@tf.function
def predict_smooth_pcc(f):
""" pcc with predictor smoothing trick"""
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
pre_prob = (1.0 - args.smoothing) * pre_prob + args.smoothing / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
@tf.function
def adap_label_smooth_pcc(f):
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
alpha = acti_func(pre_prob, a, b, c)
new_labels = (1.0 - alpha) * labels + alpha / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(new_labels, pre_prob)
@tf.function
def adap_pred_smooth_pcc(f):
n = f.shape[0]
labels = tf.eye(n)
labels = tf.reshape(labels,[-1,1])
# labels = (1.0 - args.smoothing) * labels + args.smoothing / 2
pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])
# print('pre_prob:',pre_prob)
alpha = acti_func(pre_prob, a, b, c)
pre_prob = (1.0 - alpha) * pre_prob + alpha / 2
bce = tf.keras.losses.BinaryCrossentropy()
return -bce(labels, pre_prob)
# @title Define the linear evaluation protocol { display-mode: "form" }
def logistic_fit(x_train, y_train, x_test, y_test):
logistic_regressor = sk_linear.LogisticRegression(
solver='saga', multi_class='multinomial', tol=.1, C=10.)
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
logistic_regressor.fit(x_train, y_train.ravel())
return logistic_regressor.score(x_test, y_test.ravel())
# @title Define and load the dataset, check baseline in pixel space { display-mode: "form" }
tf.compat.v1.reset_default_graph()
def map_fn(example):
image = example[FEATURE_INPUT]
image = tf.cast(image, tf.float32) / 255.0
image = tf.reshape(image, [-1]) # Flatten.
label = example[FEATURE_LABEL]
return {FEATURE_INPUT: image, FEATURE_LABEL: label}
def load_data(split):
return (tfds.load(TFDS_NAME, data_dir='/public/wangxu/data/', split=split)
.cache()
.map(map_func=map_fn)
.shuffle(1000))
def tfds_to_np(dataset):
features = list(tfds.as_numpy(dataset))
images = np.stack([f[FEATURE_INPUT].ravel() for f in features])
labels = np.stack([f[FEATURE_LABEL].ravel() for f in features])
return images, labels
dataset_train = load_data("train")
dataset_test = load_data("test")
x_train, y_train = tfds_to_np(dataset_train)
x_test, y_test = tfds_to_np(dataset_test)
tf.compat.v1.reset_default_graph()
x_train_noisy = x_train + 0.05 * np.random.randn(*x_train.shape)
x_test_noisy = x_test + 0.05 * np.random.randn(*x_test.shape)
print("Fit on half the pixels: {}. It should be around 0.835.".format(
logistic_fit(x_train_noisy[:, :DIMS//2], y_train,
x_test_noisy[:, :DIMS//2], y_test)))
def processed_train_data(dims, batch_size):
dataset = load_data("train")
dataset_batched = dataset.repeat().batch(batch_size, drop_remainder=True)
get_next = tf.compat.v1.data.make_one_shot_iterator(dataset_batched).get_next()
features = get_next[FEATURE_INPUT]
labels = get_next[FEATURE_LABEL]
# Martin: where the problem occurs
x_1, x_2 = tf.split(features, [dims, DIMS-dims], axis=-1)
return x_1, x_2, labels
class MLP(tf.keras.Model):
def __init__(self, layer_dimensions, shortcuts, dense_kwargs={}):
super(MLP, self).__init__()
self._layers = [tfkl.Dense(dimensions, **dense_kwargs)
for dimensions in layer_dimensions[:-1]]
dense_kwargs_copy = copy.deepcopy(dense_kwargs)
dense_kwargs_copy["activation"] = None
self._layers.append(tfkl.Dense(layer_dimensions[-1], **dense_kwargs_copy))
self._shortcuts = shortcuts
@property
def layers(self):
return self._layers
def __call__(self, inputs):
x = inputs
for layer in self.layers:
x = layer(x) + x if self._shortcuts else layer(x)
return x
# LayerNorm implementation copied from
# https://stackoverflow.com/questions/39095252/fail-to-implement-layer-normalization-with-keras
class LayerNorm(tfkl.Layer):
""" Layer Normalization in the style of https://arxiv.org/abs/1607.06450 """
def __init__(self, scale_initializer='ones', bias_initializer='zeros',
axes=[1,2,3], epsilon=1e-6, **kwargs):
super(LayerNorm, self).__init__(**kwargs)
self.epsilon = epsilon
self.scale_initializer = tf.keras.initializers.get(scale_initializer)
self.bias_initializer = tf.keras.initializers.get(bias_initializer)
self.axes = axes
def build(self, input_shape):
self.scale = self.add_weight(shape=(input_shape[-1],),
initializer=self.scale_initializer,
trainable=True,
name='{}_scale'.format(self.name))
self.bias = self.add_weight(shape=(input_shape[-1],),
initializer=self.bias_initializer,
trainable=True,
name='{}_bias'.format(self.name))
self.built = True
def call(self, x, mask=None):
mean = tf.keras.backend.mean(x, axis=self.axes, keepdims=True)
std = tf.keras.backend.std(x, axis=self.axes, keepdims=True)
norm = (x - mean) * (1/(std + self.epsilon))
return norm * self.scale + self.bias
def | compute_output_shape | identifier_name |
|
main.py | :]
return self._bijector_fn(y0, self._input_depth - self._num_masked,
**condition_kwargs).inverse_log_det_jacobian(
y1, event_ndims=1)
def real_nvp_default_template(hidden_layers,
shift_only=False,
activation=tf.nn.relu,
name=None,
*args, # pylint: disable=keyword-arg-before-vararg
**kwargs):
with tf.compat.v1.name_scope(name or 'real_nvp_default_template'):
def _fn(x, output_units, **condition_kwargs):
"""Fully connected MLP parameterized via `real_nvp_template`."""
if condition_kwargs:
raise NotImplementedError(
'Conditioning not implemented in the default template.')
if tensorshape_util.rank(x.shape) == 1:
x = x[tf.newaxis, ...]
reshape_output = lambda x: x[0]
else:
reshape_output = lambda x: x
for units in hidden_layers:
x = tf1.layers.dense(
inputs=x,
units=units,
activation=activation,
*args, # pylint: disable=keyword-arg-before-vararg
**kwargs)
x = tf1.layers.dense(
inputs=x,
units=(1 if shift_only else 2) * output_units,
activation=None,
*args, # pylint: disable=keyword-arg-before-vararg
**kwargs)
if shift_only:
return reshape_output(x), None
shift, log_scale = tf.split(x, 2, axis=-1)
# ** Here is the second modification.
return reshape_output(shift), 1e-7 + tf.nn.softplus(reshape_output(log_scale))
return tf1.make_template('real_nvp_default_template', _fn)
class RealNVPBijector(tf.keras.Model):
def __init__(self, dimensions, n_couplings, hidden_layers, dense_kwargs):
super(RealNVPBijector, self).__init__()
permutations = [np.random.permutation(dimensions)
for _ in range(n_couplings)]
bijectors = []
for permutation in permutations:
bijectors.append(RealNVP(
dimensions // 2,
real_nvp_default_template(hidden_layers, **dense_kwargs)))
bijectors.append(tfb.Permute(permutation))
self._bijector = tfb.Chain(bijectors)
def call(self, inputs):
return self._bijector.forward(inputs)
class InnerProdCritic(tf.keras.Model):
def call(self, x, y):
return tf.matmul(x, y, transpose_b=True)
class BilinearCritic(tf.keras.Model):
def __init__(self, feature_dim=100, **kwargs):
super(BilinearCritic, self).__init__(**kwargs)
self._W = tfkl.Dense(feature_dim, use_bias=False)
def call(self, x, y):
return tf.matmul(x, self._W(y), transpose_b=True)
# https://colab.research.google.com/github/google-research/google-research/blob/master/vbmi/vbmi_demo.ipynb
class ConcatCritic(tf.keras.Model):
def __init__(self, hidden_dim=200, layers=1, activation='relu', **kwargs):
super(ConcatCritic, self).__init__(**kwargs)
# output is scalar score
self._f = MLP([hidden_dim for _ in range(layers)]+[1], False, {"activation": "relu"})
def call(self, x, y):
batch_size = tf.shape(input=x)[0]
# Tile all possible combinations of x and y
x_tiled = tf.tile(x[None, :], (batch_size, 1, 1))
y_tiled = tf.tile(y[:, None], (1, batch_size, 1))
# xy is [batch_size * batch_size, x_dim + y_dim]
xy_pairs = tf.reshape(tf.concat((x_tiled, y_tiled), axis=2),
[batch_size * batch_size, -1])
# Compute scores for each x_i, y_j pair.
scores = self._f(xy_pairs)
return tf.transpose(a=tf.reshape(scores, [batch_size, batch_size]))
class SeparableCritic(tf.keras.Model):
def __init__(self, hidden_dim=100, output_dim=100, layers=1,
activation='relu', **kwargs):
super(SeparableCritic, self).__init__(**kwargs)
self._f_x = MLP([hidden_dim for _ in range(layers)] + [output_dim], False, {"activation": activation})
self._f_y = MLP([hidden_dim for _ in range(layers)] + [output_dim], False, {"activation": activation})
def call(self, x, y):
x_mapped = self._f_x(x)
y_mapped = self._f_y(y)
return tf.matmul(x_mapped, y_mapped, transpose_b=True)
def train(g1,
g2,
critic,
loss_fn,
learning_rate,
batch_size=TRAIN_BATCH_SIZE,
n_iters=15000,
n_evals=15,
compute_jacobian=False,
noise_std=0.0,
data_dimensions=DIMS//2,
n_iter=1,
loss_name='InfoNCE',
):
"""Runs the training loop for a fixed model.
Args:
g1: Function, maps input1 to representation.
g2: Function, maps input2 to representation.
critic: Function, maps two representations to scalar.
loss_fn: Function, mutual information estimator.
learning_rate: Learning rate.
batch_size: Training batch size.
n_iters: Number of optimization iterations.
n_evals: Number of model evaluations.
compute_jacobian: Whether to estimate the singular values of the Jacobian.
noise_std: Standard deviation for the Gaussian noise. Default is 0.0.
data_dimensions: The dimension of the data. By default it's half of the
original data dimension.
Returns:
Returns and instance of `Results` tuple.
"""
x_1, x_2, _ = processed_train_data(data_dimensions, batch_size)
if noise_std > 0.0:
assert x_1.shape == x_2.shape, "X1 and X2 shapes must agree to add noise!"
noise = noise_std * tf.random.normal(x_1.shape)
x_1 += noise
x_2 += noise
# Compute the representations.
code_1, code_2 = g1(x_1), g2(x_2)
critic_matrix = critic(code_1, code_2)
# Compute the Jacobian of g1 if needed.
if compute_jacobian:
jacobian = gradients.batch_jacobian(code_1, x_1, use_pfor=False)
singular_values = tf.linalg.svd(jacobian, compute_uv=False)
# Optimizer setup.
loss = loss_fn(critic_matrix)
optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate)
if not loss_name == 'wpc':
optimizer_op = optimizer.minimize(loss)
else:
gvs = optimizer.compute_gradients(loss)
capped_gvs = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gvs]
optimizer_op = optimizer.apply_gradients(capped_gvs)
with tf.compat.v1.Session() as session:
session.run(tf.compat.v1.global_variables_initializer())
# Subgraph for eval (add noise to input if necessary)
data_ph = tf.compat.v1.placeholder(tf.float32, shape=[None, data_dimensions])
data_ph_noisy = data_ph + noise_std * tf.random.normal(tf.shape(input=data_ph))
codes = g1(data_ph_noisy)
training_losses, testing_losses, classification_accuracies, iters, sigmas \
= [], [], [], [], []
# Main training loop.
for iter_n in range(n_iters):
# Evaluate the model performance.
if iter_n % (n_iters // n_evals) == 0:
iters.append(iter_n)
accuracy = get_classification_accuracy(session, codes, data_ph, data_dimensions)
classification_accuracies.append(accuracy)
testing_losses.append(
get_testing_loss(x_test, session, loss, data_ph, data_dimensions))
if compute_jacobian:
sigmas.append(session.run(singular_values))
print("{:d}th iter Loss_name {} Step {:>10d} fit {:>.5f} DS {} B {:d} lr {:f}".format(\
n_iter, loss_name, iter_n, accuracy, args.dataset, args.batch_size, args.lr))
# Run one optimization step.
loss_np, _ = session.run([loss, optimizer_op])
training_losses.append(loss_np)
return Results(iterations=iters,
training_losses=training_losses,
testing_losses=testing_losses,
classification_accuracies=classification_accuracies,
singular_values=sigmas)
def run_sweep(nets, critics, loss_fns, exp_name, **kwargs):
"""Runs the sweep across encoder networks, critics, and the estimators."""
grid = itertools.product(nets, critics, loss_fns)
data_frames = []
results_with_singular_values = [] | for nets_name, critic_name, loss_name in grid:
print("[New experiment] encoder: {}, critic: {}, loss: {}".format(
nets_name, critic_name, loss_name)) | random_line_split |
|
preprocessing.py | higher than point n.
# (i.e. contacts can only decrease when increasing distance)
if smooth and mat_n > 2:
ir = IsotonicRegression(increasing=False)
dist[~np.isfinite(dist)] = 0
dist = ir.fit_transform(range(len(dist)), dist)
return dist
def get_detectable_bins(mat, n_mads=3, inter=False):
"""
Returns lists of detectable indices after excluding low interacting bins
based on the proportion of zero pixel values in the matrix bins.
Parameters
----------
mat : scipy.sparse.coo_matrix
A Hi-C matrix in tihe form of a 2D numpy array or coo matrix
n_mads : int
Number of median absolute deviation below the median required to
consider bins non-detectable.
inter : bool
Whether the matrix is interchromosomal. Default is to consider the
matrix is intrachromosomal (i.e. upper symmetric).
Returns
-------
numpy ndarray :
tuple of 2 1D arrays containing indices of low interacting rows and
columns, respectively.
"""
matrix = mat.copy()
matrix.eliminate_zeros()
def | (x): return ss.median_abs_deviation(x, nan_policy="omit")
if not inter:
if matrix.shape[0] != matrix.shape[1]:
raise ValueError("Intrachromosomal matrices must be symmetric.")
# Replace nonzero pixels by ones to work on prop. of nonzero pixels
matrix.data = np.ones(matrix.data.shape)
# Compute number of nonzero values in each bin
sum_bins = sum_mat_bins(matrix)
# Compute variation in the number of nonzero pixels
sum_mad = mad(sum_bins)
# Find poor interacting rows and columns
sum_med = np.median(sum_bins)
detect_threshold = max(1, sum_med - sum_mad * n_mads)
# Removal of poor interacting rows and columns
good_bins = np.flatnonzero(sum_bins >= detect_threshold)
good_bins = (good_bins, good_bins)
else:
# Adapted for asymetric matrices (need to compute rows and columns)
sum_rows, sum_cols = matrix.sum(axis=1).A1, matrix.sum(axis=0).A1
mad_rows, mad_cols = mad(sum_rows), mad(sum_cols)
med_rows, med_cols = np.median(sum_rows), np.median(sum_cols)
detect_threshold_rows = max(1, med_rows - mad_rows * n_mads)
detect_threshold_cols = max(1, med_cols - mad_cols * n_mads)
good_rows = np.flatnonzero(sum_rows > detect_threshold_rows)
good_cols = np.flatnonzero(sum_cols > detect_threshold_cols)
good_bins = (good_rows, good_cols)
return good_bins
def detrend(
matrix,
detectable_bins=None,
max_dist=None,
smooth=False,
fun=np.nanmean,
max_val=10,
):
"""
Detrends a Hi-C matrix by the distance law.
The input matrix should have been normalised beforehandand.
Parameters
----------
matrix : scipy.sparse.csr_matrix
The normalised intrachromosomal Hi-C matrix to detrend.
detectable_bins : tuple
Tuple containing a list of detectable rows and a list of columns on
which to perform detrending. Poorly interacting indices have been
excluded.
max_dist : int
Maximum number of bins from the diagonal at which to compute trend.
smooth : bool
Whether to use isotonic regression to smooth the trend.
fun : callable
Function to use on each diagonal to compute the trend.
max_val : float or None
Maximum value in the detrended matrix. Set to None to disable
Returns
-------
numpy.ndarray :
The detrended Hi-C matrix.
"""
matrix = matrix.tocsr()
y = distance_law(
matrix,
detectable_bins=detectable_bins,
max_dist=max_dist,
smooth=smooth,
fun=fun,
)
y[np.isnan(y)] = 0.0
# Detrending by the distance law
clean_mat = matrix.tocoo()
# clean_mat.data /= y_savgol[abs(clean_mat.row - clean_mat.col)]
try:
clean_mat.data = clean_mat.data / y[abs(clean_mat.row - clean_mat.col)]
# If no nonzero value in matrix, do nothing
except TypeError:
pass
clean_mat = clean_mat.tocsr()
if max_val is not None:
clean_mat[clean_mat >= max_val] = 1
return clean_mat
def ztransform(matrix):
"""
Z transformation for Hi-C matrices.
Parameters
----------
matrix : scipy.sparse.coo_matrix
A Hi-C matrix in sparse format.
Returns
-------
scipy.sparse.coo_matrix:
The detrended Hi-C matrix
"""
mat = matrix.copy()
mu = np.mean(mat.data)
sd = np.std(mat.data)
mat.data -= mu
mat.data /= sd
return mat
def sum_mat_bins(mat):
"""
Compute the sum of matrices bins (i.e. rows or columns) using
only the upper triangle, assuming symmetrical matrices.
Parameters
----------
mat : scipy.sparse.coo_matrix
Contact map in sparse format, either in upper triangle or
full matrix.
Returns
-------
numpy.ndarray :
1D array of bin sums.
"""
# Equivalaent to row or col sum on a full matrix
# Note: mat.sum returns a 'matrix' object. A1 extracts the 1D flat array
# from the matrix
return mat.sum(axis=0).A1 + mat.sum(axis=1).A1 - mat.diagonal(0)
def subsample_contacts(M, n_contacts):
"""Bootstrap sampling of contacts in a sparse Hi-C map.
Parameters
----------
M : scipy.sparse.coo_matrix
The input Hi-C contact map in sparse format.
n_contacts : int
The number of contacts to sample.
Returns
-------
scipy.sparse.coo_matrix
A new matrix with a fraction of the original contacts.
"""
S = M.data.copy()
# Match cell idx to cumulative number of contacts
cum_counts = np.cumsum(S)
# Total number of contacts to sample
tot_contacts = int(cum_counts[-1])
# Sample desired number of contacts from the range(0, n_contacts) array
sampled_contacts = np.random.choice(
int(tot_contacts), size=(n_contacts), replace=False
)
# Get indices of sampled contacts in the cum_counts array
idx = np.searchsorted(cum_counts, sampled_contacts, side="right")
# Bin those indices to the same dimensions as matrix data to get counts
sampled_counts = np.bincount(idx, minlength=S.shape[0])
# Get nonzero values to build new sparse matrix
nnz_mask = sampled_counts > 0
sampled_counts = sampled_counts[nnz_mask].astype(np.float64)
sampled_rows = M.row[nnz_mask]
sampled_cols = M.col[nnz_mask]
return sp.coo_matrix(
(sampled_counts, (sampled_rows, sampled_cols)),
shape=(M.shape[0], M.shape[1]),
)
def frame_missing_mask(mask, kernel_shape, sym_upper=False, max_dist=None):
"""
Adds a frame around input mask, given a kernel. The goal of this
frame is define margins around the matrix where the kernel will not perform
convolution (denoted by 1). If the matrix is upper symmetric, a margin of
half the kernel's width is added below the diagonal and a maximum distance
from the diagonal above which margins need not be drawn can be considered.
Otherwise Margins are simply added on all 4 sides of the matrix.
::
signal kernel _________
______ ____ |#######|
| | | | ==> |# #|
| | |___| |# #|
| | |# #|
|_____| |# #|
|#######|
--------
Parameters
----------
mask : scipy.sparse.csr_matrix of bool
The mask around which to add margins.
kernels_shape : tuple of ints
The number of rows and kernel in the input kernel. Margins will be half
these values.
sym_upper : bool
Whether the signal is a symmetric upper triangle matrix. If so, values
on a margin below the diagonal will be masked.
max_dist : int or None
Number of diagonals to keep
Returns
-------
framed_mask : scipy.sparse.csr_matrix of bool
The input mask with a padding of True around the edges. If sym_upper
is True, a padding is also added below the diagonal.
"""
if mask.dtype != bool:
raise ValueError("Mask must contain boolean values")
if not sp.issparse(mask):
raise ValueError("Mask must be a sparse matrix")
framed_mask = mask.copy()
ms, ns = mask.shape
mk, nk = kernel_shape
if sym_upper and (max_dist is not None):
# Remove diagonals further than scan distance in the input mask
framed_mask = diag_trim(framed_mask, max_dist + max(nk | mad | identifier_name |
preprocessing.py | higher than point n.
# (i.e. contacts can only decrease when increasing distance)
if smooth and mat_n > 2:
ir = IsotonicRegression(increasing=False)
dist[~np.isfinite(dist)] = 0
dist = ir.fit_transform(range(len(dist)), dist)
return dist
def get_detectable_bins(mat, n_mads=3, inter=False):
"""
Returns lists of detectable indices after excluding low interacting bins
based on the proportion of zero pixel values in the matrix bins.
Parameters
----------
mat : scipy.sparse.coo_matrix
A Hi-C matrix in tihe form of a 2D numpy array or coo matrix
n_mads : int
Number of median absolute deviation below the median required to
consider bins non-detectable.
inter : bool
Whether the matrix is interchromosomal. Default is to consider the
matrix is intrachromosomal (i.e. upper symmetric).
Returns
-------
numpy ndarray :
tuple of 2 1D arrays containing indices of low interacting rows and
columns, respectively.
"""
matrix = mat.copy()
matrix.eliminate_zeros()
def mad(x): return ss.median_abs_deviation(x, nan_policy="omit")
if not inter:
if matrix.shape[0] != matrix.shape[1]:
raise ValueError("Intrachromosomal matrices must be symmetric.")
# Replace nonzero pixels by ones to work on prop. of nonzero pixels
matrix.data = np.ones(matrix.data.shape)
# Compute number of nonzero values in each bin
sum_bins = sum_mat_bins(matrix)
# Compute variation in the number of nonzero pixels
sum_mad = mad(sum_bins)
# Find poor interacting rows and columns
sum_med = np.median(sum_bins)
detect_threshold = max(1, sum_med - sum_mad * n_mads)
# Removal of poor interacting rows and columns
good_bins = np.flatnonzero(sum_bins >= detect_threshold)
good_bins = (good_bins, good_bins)
else:
# Adapted for asymetric matrices (need to compute rows and columns)
|
return good_bins
def detrend(
matrix,
detectable_bins=None,
max_dist=None,
smooth=False,
fun=np.nanmean,
max_val=10,
):
"""
Detrends a Hi-C matrix by the distance law.
The input matrix should have been normalised beforehandand.
Parameters
----------
matrix : scipy.sparse.csr_matrix
The normalised intrachromosomal Hi-C matrix to detrend.
detectable_bins : tuple
Tuple containing a list of detectable rows and a list of columns on
which to perform detrending. Poorly interacting indices have been
excluded.
max_dist : int
Maximum number of bins from the diagonal at which to compute trend.
smooth : bool
Whether to use isotonic regression to smooth the trend.
fun : callable
Function to use on each diagonal to compute the trend.
max_val : float or None
Maximum value in the detrended matrix. Set to None to disable
Returns
-------
numpy.ndarray :
The detrended Hi-C matrix.
"""
matrix = matrix.tocsr()
y = distance_law(
matrix,
detectable_bins=detectable_bins,
max_dist=max_dist,
smooth=smooth,
fun=fun,
)
y[np.isnan(y)] = 0.0
# Detrending by the distance law
clean_mat = matrix.tocoo()
# clean_mat.data /= y_savgol[abs(clean_mat.row - clean_mat.col)]
try:
clean_mat.data = clean_mat.data / y[abs(clean_mat.row - clean_mat.col)]
# If no nonzero value in matrix, do nothing
except TypeError:
pass
clean_mat = clean_mat.tocsr()
if max_val is not None:
clean_mat[clean_mat >= max_val] = 1
return clean_mat
def ztransform(matrix):
"""
Z transformation for Hi-C matrices.
Parameters
----------
matrix : scipy.sparse.coo_matrix
A Hi-C matrix in sparse format.
Returns
-------
scipy.sparse.coo_matrix:
The detrended Hi-C matrix
"""
mat = matrix.copy()
mu = np.mean(mat.data)
sd = np.std(mat.data)
mat.data -= mu
mat.data /= sd
return mat
def sum_mat_bins(mat):
"""
Compute the sum of matrices bins (i.e. rows or columns) using
only the upper triangle, assuming symmetrical matrices.
Parameters
----------
mat : scipy.sparse.coo_matrix
Contact map in sparse format, either in upper triangle or
full matrix.
Returns
-------
numpy.ndarray :
1D array of bin sums.
"""
# Equivalaent to row or col sum on a full matrix
# Note: mat.sum returns a 'matrix' object. A1 extracts the 1D flat array
# from the matrix
return mat.sum(axis=0).A1 + mat.sum(axis=1).A1 - mat.diagonal(0)
def subsample_contacts(M, n_contacts):
"""Bootstrap sampling of contacts in a sparse Hi-C map.
Parameters
----------
M : scipy.sparse.coo_matrix
The input Hi-C contact map in sparse format.
n_contacts : int
The number of contacts to sample.
Returns
-------
scipy.sparse.coo_matrix
A new matrix with a fraction of the original contacts.
"""
S = M.data.copy()
# Match cell idx to cumulative number of contacts
cum_counts = np.cumsum(S)
# Total number of contacts to sample
tot_contacts = int(cum_counts[-1])
# Sample desired number of contacts from the range(0, n_contacts) array
sampled_contacts = np.random.choice(
int(tot_contacts), size=(n_contacts), replace=False
)
# Get indices of sampled contacts in the cum_counts array
idx = np.searchsorted(cum_counts, sampled_contacts, side="right")
# Bin those indices to the same dimensions as matrix data to get counts
sampled_counts = np.bincount(idx, minlength=S.shape[0])
# Get nonzero values to build new sparse matrix
nnz_mask = sampled_counts > 0
sampled_counts = sampled_counts[nnz_mask].astype(np.float64)
sampled_rows = M.row[nnz_mask]
sampled_cols = M.col[nnz_mask]
return sp.coo_matrix(
(sampled_counts, (sampled_rows, sampled_cols)),
shape=(M.shape[0], M.shape[1]),
)
def frame_missing_mask(mask, kernel_shape, sym_upper=False, max_dist=None):
"""
Adds a frame around input mask, given a kernel. The goal of this
frame is define margins around the matrix where the kernel will not perform
convolution (denoted by 1). If the matrix is upper symmetric, a margin of
half the kernel's width is added below the diagonal and a maximum distance
from the diagonal above which margins need not be drawn can be considered.
Otherwise Margins are simply added on all 4 sides of the matrix.
::
signal kernel _________
______ ____ |#######|
| | | | ==> |# #|
| | |___| |# #|
| | |# #|
|_____| |# #|
|#######|
--------
Parameters
----------
mask : scipy.sparse.csr_matrix of bool
The mask around which to add margins.
kernels_shape : tuple of ints
The number of rows and kernel in the input kernel. Margins will be half
these values.
sym_upper : bool
Whether the signal is a symmetric upper triangle matrix. If so, values
on a margin below the diagonal will be masked.
max_dist : int or None
Number of diagonals to keep
Returns
-------
framed_mask : scipy.sparse.csr_matrix of bool
The input mask with a padding of True around the edges. If sym_upper
is True, a padding is also added below the diagonal.
"""
if mask.dtype != bool:
raise ValueError("Mask must contain boolean values")
if not sp.issparse(mask):
raise ValueError("Mask must be a sparse matrix")
framed_mask = mask.copy()
ms, ns = mask.shape
mk, nk = kernel_shape
if sym_upper and (max_dist is not None):
# Remove diagonals further than scan distance in the input mask
framed_mask = diag_trim(framed_mask, max_dist + max(nk | sum_rows, sum_cols = matrix.sum(axis=1).A1, matrix.sum(axis=0).A1
mad_rows, mad_cols = mad(sum_rows), mad(sum_cols)
med_rows, med_cols = np.median(sum_rows), np.median(sum_cols)
detect_threshold_rows = max(1, med_rows - mad_rows * n_mads)
detect_threshold_cols = max(1, med_cols - mad_cols * n_mads)
good_rows = np.flatnonzero(sum_rows > detect_threshold_rows)
good_cols = np.flatnonzero(sum_cols > detect_threshold_cols)
good_bins = (good_rows, good_cols) | conditional_block |
preprocessing.py | higher than point n.
# (i.e. contacts can only decrease when increasing distance)
if smooth and mat_n > 2:
ir = IsotonicRegression(increasing=False)
dist[~np.isfinite(dist)] = 0
dist = ir.fit_transform(range(len(dist)), dist)
return dist
def get_detectable_bins(mat, n_mads=3, inter=False):
"""
Returns lists of detectable indices after excluding low interacting bins
based on the proportion of zero pixel values in the matrix bins.
Parameters
----------
mat : scipy.sparse.coo_matrix
A Hi-C matrix in tihe form of a 2D numpy array or coo matrix
n_mads : int
Number of median absolute deviation below the median required to
consider bins non-detectable.
inter : bool
Whether the matrix is interchromosomal. Default is to consider the
matrix is intrachromosomal (i.e. upper symmetric).
Returns
-------
numpy ndarray :
tuple of 2 1D arrays containing indices of low interacting rows and
columns, respectively.
"""
matrix = mat.copy()
matrix.eliminate_zeros()
def mad(x): return ss.median_abs_deviation(x, nan_policy="omit")
if not inter:
if matrix.shape[0] != matrix.shape[1]:
raise ValueError("Intrachromosomal matrices must be symmetric.")
# Replace nonzero pixels by ones to work on prop. of nonzero pixels
matrix.data = np.ones(matrix.data.shape)
# Compute number of nonzero values in each bin
sum_bins = sum_mat_bins(matrix)
# Compute variation in the number of nonzero pixels
sum_mad = mad(sum_bins)
# Find poor interacting rows and columns
sum_med = np.median(sum_bins)
detect_threshold = max(1, sum_med - sum_mad * n_mads)
# Removal of poor interacting rows and columns
good_bins = np.flatnonzero(sum_bins >= detect_threshold)
good_bins = (good_bins, good_bins)
else:
# Adapted for asymetric matrices (need to compute rows and columns)
sum_rows, sum_cols = matrix.sum(axis=1).A1, matrix.sum(axis=0).A1
mad_rows, mad_cols = mad(sum_rows), mad(sum_cols)
med_rows, med_cols = np.median(sum_rows), np.median(sum_cols)
detect_threshold_rows = max(1, med_rows - mad_rows * n_mads)
detect_threshold_cols = max(1, med_cols - mad_cols * n_mads)
good_rows = np.flatnonzero(sum_rows > detect_threshold_rows)
good_cols = np.flatnonzero(sum_cols > detect_threshold_cols)
good_bins = (good_rows, good_cols)
return good_bins
def detrend(
matrix,
detectable_bins=None,
max_dist=None,
smooth=False,
fun=np.nanmean,
max_val=10,
):
"""
Detrends a Hi-C matrix by the distance law.
The input matrix should have been normalised beforehandand.
Parameters
----------
matrix : scipy.sparse.csr_matrix
The normalised intrachromosomal Hi-C matrix to detrend.
detectable_bins : tuple
Tuple containing a list of detectable rows and a list of columns on
which to perform detrending. Poorly interacting indices have been
excluded.
max_dist : int
Maximum number of bins from the diagonal at which to compute trend.
smooth : bool
Whether to use isotonic regression to smooth the trend.
fun : callable
Function to use on each diagonal to compute the trend.
max_val : float or None
Maximum value in the detrended matrix. Set to None to disable
Returns
-------
numpy.ndarray :
The detrended Hi-C matrix.
"""
matrix = matrix.tocsr()
y = distance_law(
matrix,
detectable_bins=detectable_bins,
max_dist=max_dist,
smooth=smooth,
fun=fun,
)
y[np.isnan(y)] = 0.0
# Detrending by the distance law
clean_mat = matrix.tocoo()
# clean_mat.data /= y_savgol[abs(clean_mat.row - clean_mat.col)]
try:
clean_mat.data = clean_mat.data / y[abs(clean_mat.row - clean_mat.col)]
# If no nonzero value in matrix, do nothing
except TypeError:
pass
clean_mat = clean_mat.tocsr()
if max_val is not None:
clean_mat[clean_mat >= max_val] = 1
return clean_mat
def ztransform(matrix):
"""
Z transformation for Hi-C matrices.
Parameters
----------
matrix : scipy.sparse.coo_matrix
A Hi-C matrix in sparse format. |
Returns
-------
scipy.sparse.coo_matrix:
The detrended Hi-C matrix
"""
mat = matrix.copy()
mu = np.mean(mat.data)
sd = np.std(mat.data)
mat.data -= mu
mat.data /= sd
return mat
def sum_mat_bins(mat):
"""
Compute the sum of matrices bins (i.e. rows or columns) using
only the upper triangle, assuming symmetrical matrices.
Parameters
----------
mat : scipy.sparse.coo_matrix
Contact map in sparse format, either in upper triangle or
full matrix.
Returns
-------
numpy.ndarray :
1D array of bin sums.
"""
# Equivalaent to row or col sum on a full matrix
# Note: mat.sum returns a 'matrix' object. A1 extracts the 1D flat array
# from the matrix
return mat.sum(axis=0).A1 + mat.sum(axis=1).A1 - mat.diagonal(0)
def subsample_contacts(M, n_contacts):
"""Bootstrap sampling of contacts in a sparse Hi-C map.
Parameters
----------
M : scipy.sparse.coo_matrix
The input Hi-C contact map in sparse format.
n_contacts : int
The number of contacts to sample.
Returns
-------
scipy.sparse.coo_matrix
A new matrix with a fraction of the original contacts.
"""
S = M.data.copy()
# Match cell idx to cumulative number of contacts
cum_counts = np.cumsum(S)
# Total number of contacts to sample
tot_contacts = int(cum_counts[-1])
# Sample desired number of contacts from the range(0, n_contacts) array
sampled_contacts = np.random.choice(
int(tot_contacts), size=(n_contacts), replace=False
)
# Get indices of sampled contacts in the cum_counts array
idx = np.searchsorted(cum_counts, sampled_contacts, side="right")
# Bin those indices to the same dimensions as matrix data to get counts
sampled_counts = np.bincount(idx, minlength=S.shape[0])
# Get nonzero values to build new sparse matrix
nnz_mask = sampled_counts > 0
sampled_counts = sampled_counts[nnz_mask].astype(np.float64)
sampled_rows = M.row[nnz_mask]
sampled_cols = M.col[nnz_mask]
return sp.coo_matrix(
(sampled_counts, (sampled_rows, sampled_cols)),
shape=(M.shape[0], M.shape[1]),
)
def frame_missing_mask(mask, kernel_shape, sym_upper=False, max_dist=None):
"""
Adds a frame around input mask, given a kernel. The goal of this
frame is define margins around the matrix where the kernel will not perform
convolution (denoted by 1). If the matrix is upper symmetric, a margin of
half the kernel's width is added below the diagonal and a maximum distance
from the diagonal above which margins need not be drawn can be considered.
Otherwise Margins are simply added on all 4 sides of the matrix.
::
signal kernel _________
______ ____ |#######|
| | | | ==> |# #|
| | |___| |# #|
| | |# #|
|_____| |# #|
|#######|
--------
Parameters
----------
mask : scipy.sparse.csr_matrix of bool
The mask around which to add margins.
kernels_shape : tuple of ints
The number of rows and kernel in the input kernel. Margins will be half
these values.
sym_upper : bool
Whether the signal is a symmetric upper triangle matrix. If so, values
on a margin below the diagonal will be masked.
max_dist : int or None
Number of diagonals to keep
Returns
-------
framed_mask : scipy.sparse.csr_matrix of bool
The input mask with a padding of True around the edges. If sym_upper
is True, a padding is also added below the diagonal.
"""
if mask.dtype != bool:
raise ValueError("Mask must contain boolean values")
if not sp.issparse(mask):
raise ValueError("Mask must be a sparse matrix")
framed_mask = mask.copy()
ms, ns = mask.shape
mk, nk = kernel_shape
if sym_upper and (max_dist is not None):
# Remove diagonals further than scan distance in the input mask
framed_mask = diag_trim(framed_mask, max_dist + max(nk | random_line_split |
|
preprocessing.py | raise ValueError("input type must be scipy.sparse.csr_matrix")
# Trim diagonals by removing all elements further than n in the
# upper triangle
trimmed = sp.tril(mat, n, format="csr")
trimmed = sp.triu(trimmed, format="csr")
else:
trimmed = mat.copy()
n_diags = trimmed.shape[0]
for diag in range(n, n_diags):
set_mat_diag(trimmed, diag, 0)
return trimmed
return trimmed
def distance_law(
matrix, detectable_bins=None, max_dist=None, smooth=True, fun=np.nanmean
):
"""
Computes genomic distance law by averaging over each diagonal in the upper
triangle matrix. If a list of detectable bins is provided, pixels in
missing bins will be excluded from the averages. A maximum distance can be
specified to define how many diagonals should be computed.
parameters
----------
matrix: scipy.sparse.csr_matrix
the input matrix to compute distance law from.
detectable_bins : numpy.ndarray of ints
An array of detectable bins indices to consider when computing
distance law.
max_dist : int
Maximum distance from diagonal, in number of bins in which to compute
distance law
smooth : bool
Whether to use isotonic regression to smooth the distance law.
fun : callable
A function to apply on each diagonal. Defaults to mean.
Returns
-------
dist: np.ndarray
the output genomic distance law.
example
-------
>>> m = np.ones((3,3))
>>> m += np.array([1,2,3])
>>> m
array([[2., 3., 4.],
[2., 3., 4.],
[2., 3., 4.]])
>>> distance_law(csr_matrix(m))
array([3. , 3.5, 4. ])
"""
mat_n = matrix.shape[0]
if max_dist is None:
max_dist = mat_n
n_diags = min(mat_n, max_dist + 1)
dist = np.zeros(mat_n)
if detectable_bins is None:
detectable_bins = np.array(range(mat_n))
for diag in range(n_diags):
# Find detectable which fall in diagonal
detect_mask = np.zeros(mat_n, dtype=bool)
detect_mask[detectable_bins] = 1
# Find bins which are detectable in the diagonal (intersect of
# hori and verti)
detect_mask_h = detect_mask[: (mat_n - diag)]
detect_mask_v = detect_mask[mat_n - (mat_n - diag) :]
detect_mask_diag = detect_mask_h & detect_mask_v
detect_diag = matrix.diagonal(diag)[detect_mask_diag]
dist[diag] = fun(detect_diag[detect_diag > 0])
# Smooth the curve using isotonic regression: Find closest approximation
# with the condition that point n+1 cannot be higher than point n.
# (i.e. contacts can only decrease when increasing distance)
if smooth and mat_n > 2:
ir = IsotonicRegression(increasing=False)
dist[~np.isfinite(dist)] = 0
dist = ir.fit_transform(range(len(dist)), dist)
return dist
def get_detectable_bins(mat, n_mads=3, inter=False):
"""
Returns lists of detectable indices after excluding low interacting bins
based on the proportion of zero pixel values in the matrix bins.
Parameters
----------
mat : scipy.sparse.coo_matrix
A Hi-C matrix in tihe form of a 2D numpy array or coo matrix
n_mads : int
Number of median absolute deviation below the median required to
consider bins non-detectable.
inter : bool
Whether the matrix is interchromosomal. Default is to consider the
matrix is intrachromosomal (i.e. upper symmetric).
Returns
-------
numpy ndarray :
tuple of 2 1D arrays containing indices of low interacting rows and
columns, respectively.
"""
matrix = mat.copy()
matrix.eliminate_zeros()
def mad(x): return ss.median_abs_deviation(x, nan_policy="omit")
if not inter:
if matrix.shape[0] != matrix.shape[1]:
raise ValueError("Intrachromosomal matrices must be symmetric.")
# Replace nonzero pixels by ones to work on prop. of nonzero pixels
matrix.data = np.ones(matrix.data.shape)
# Compute number of nonzero values in each bin
sum_bins = sum_mat_bins(matrix)
# Compute variation in the number of nonzero pixels
sum_mad = mad(sum_bins)
# Find poor interacting rows and columns
sum_med = np.median(sum_bins)
detect_threshold = max(1, sum_med - sum_mad * n_mads)
# Removal of poor interacting rows and columns
good_bins = np.flatnonzero(sum_bins >= detect_threshold)
good_bins = (good_bins, good_bins)
else:
# Adapted for asymetric matrices (need to compute rows and columns)
sum_rows, sum_cols = matrix.sum(axis=1).A1, matrix.sum(axis=0).A1
mad_rows, mad_cols = mad(sum_rows), mad(sum_cols)
med_rows, med_cols = np.median(sum_rows), np.median(sum_cols)
detect_threshold_rows = max(1, med_rows - mad_rows * n_mads)
detect_threshold_cols = max(1, med_cols - mad_cols * n_mads)
good_rows = np.flatnonzero(sum_rows > detect_threshold_rows)
good_cols = np.flatnonzero(sum_cols > detect_threshold_cols)
good_bins = (good_rows, good_cols)
return good_bins
def detrend(
matrix,
detectable_bins=None,
max_dist=None,
smooth=False,
fun=np.nanmean,
max_val=10,
):
"""
Detrends a Hi-C matrix by the distance law.
The input matrix should have been normalised beforehandand.
Parameters
----------
matrix : scipy.sparse.csr_matrix
The normalised intrachromosomal Hi-C matrix to detrend.
detectable_bins : tuple
Tuple containing a list of detectable rows and a list of columns on
which to perform detrending. Poorly interacting indices have been
excluded.
max_dist : int
Maximum number of bins from the diagonal at which to compute trend.
smooth : bool
Whether to use isotonic regression to smooth the trend.
fun : callable
Function to use on each diagonal to compute the trend.
max_val : float or None
Maximum value in the detrended matrix. Set to None to disable
Returns
-------
numpy.ndarray :
The detrended Hi-C matrix.
"""
matrix = matrix.tocsr()
y = distance_law(
matrix,
detectable_bins=detectable_bins,
max_dist=max_dist,
smooth=smooth,
fun=fun,
)
y[np.isnan(y)] = 0.0
# Detrending by the distance law
clean_mat = matrix.tocoo()
# clean_mat.data /= y_savgol[abs(clean_mat.row - clean_mat.col)]
try:
clean_mat.data = clean_mat.data / y[abs(clean_mat.row - clean_mat.col)]
# If no nonzero value in matrix, do nothing
except TypeError:
pass
clean_mat = clean_mat.tocsr()
if max_val is not None:
clean_mat[clean_mat >= max_val] = 1
return clean_mat
def ztransform(matrix):
"""
Z transformation for Hi-C matrices.
Parameters
----------
matrix : scipy.sparse.coo_matrix
A Hi-C matrix in sparse format.
Returns
-------
scipy.sparse.coo_matrix:
The detrended Hi-C matrix
"""
mat = matrix.copy()
mu = np.mean(mat.data)
sd = np.std(mat.data)
mat.data -= mu
mat.data /= sd
return mat
def sum_mat_bins(mat):
"""
Compute the sum of matrices bins (i.e. rows or columns) using
only the upper triangle, assuming symmetrical matrices.
Parameters
----------
mat : scipy.sparse.coo_matrix
Contact map in sparse format, either in upper triangle or
full matrix.
Returns
-------
numpy.ndarray :
1D array of bin sums.
"""
# Equivalaent to row or col sum on a full matrix
# Note: mat.sum returns a 'matrix' object. A1 extracts the 1D flat array
# from the matrix
return mat.sum(axis=0).A1 + mat.sum(axis=1).A1 - mat.diagonal(0)
def subsample_contacts(M, n_contacts):
"""Bootstrap | """
Trim an upper triangle sparse matrix so that only the first n diagonals
are kept.
Parameters
----------
mat : scipy.sparse.csr_matrix or numpy.ndarray
The sparse matrix to be trimmed
n : int
The number of diagonals from the center to keep (0-based).
Returns
-------
scipy.sparse.dia_matrix or numpy.ndarray:
The diagonally trimmed upper triangle matrix with only the first
n diagonal.
"""
if sp.issparse(mat):
if mat.format != "csr": | identifier_body |
|
graph.service.ts | key.SankeyNode<SNodeExtra, SLinkExtra>;
export type SLink = d3Sankey.SankeyLink<SNodeExtra, SLinkExtra>;
export interface DAG {
nodes: SNode[];
links: SLink[];
}
// -- Dag Node --
@Injectable({ providedIn: 'root' })
export class GraphService {
private docGuids = {};
private docDb: Db = null;
private docs = {};
private nextDocGuid = 0;
private filterOrder = [];
private runningFilters = false;
public updateSubject = new Rx.BehaviorSubject(0);
public updateViewSubject = new Rx.BehaviorSubject(0);
public visualStyle = true;
public visualZoom = 1;
constructor(
private messageService: MessageService,
private http: HttpClient) {
this.addTab("ISO");
}
public runFilters(changedTab: GraphTab, parentChanged: boolean)
{
if (this.runningFilters)
return; // prevent re-entry
this.runningFilters = true;
var tabs = this.graphTabs;
var anyChanged = false;
for (var i of this.filterOrder)
{ | if (anyChanged || t.column.autoFilterSrc == changedTab.column || (parentChanged && t == changedTab))
{
anyChanged = true;
// filter child tree
GraphFilter.runFilter(t.column);
}
}
//if (anyChanged)
this.updateSubject.next(0);
this.runningFilters = false;
}
getGuid(id: string, type: string, rev: string, createMissing: boolean = true): number {
var key = `${type}-${id}-${rev}`;
if (key in this.docGuids)
return this.docGuids[key];
if (!createMissing)
return null;
var value = this.nextDocGuid++;
this.docGuids[key] = value;
return value;
}
getDbIndex() : Observable<Db> {
if (this.docDb)
return of(this.docDb);
return this.http.get<Db>('assets/output/docs-index.json', {responseType: 'json'})
.pipe(
tap(
data => {
this.docDb = data;
},
error => this.handleError("getDbIndex", [])
)
);
}
getDoc(id: string) : Observable<Doc2> {
if (this.docs[id])
return of(this.docs[id]);
return this.http.get<Doc2>('assets/output/docs-' + id + '.json', {responseType: 'json'})
.pipe(
tap(
data => {
this.docs[id] = data;
},
error => this.handleError("getDoc", [])
)
);
}
getDocTypes() : Observable<CategoryList> {
return this.getDbIndex().pipe(
map(
data => {
return data.docs.map(v => { return { id: v.id, title: v.type }; });
}
)
);
}
private addToDoc(parent: FullDocNode, input: DocNode2) {
var child = new FullDocNode(input);
if (parent)
{
parent.children.push(child);
}
// Recurse
for (var c of input.children)
{
this.addToDoc(child, c);
}
return child;
}
getFullDocByType(id: string) : Observable<FullDocNode> {
return this.getDoc(id).pipe(
map(
data => {
return this.addToDoc(null, data);
}
)
);
}
getChangeLog(): Observable<Change[]> {
return this.getDbIndex().pipe(
map(
data => {
return data.changelog;
}
)
);
}
// Live state management: maybe move this to a different service.
public graphTabs: GraphTab[] = [ ];
public selectedTab: number = 0;
public get canAdd(): boolean {
return this.graphTabs.length < 3;
}
public addTab(id: string, filterTopLevelKeys: string[] = null, customName: string = null) {
if (!this.canAdd)
return;
this.getFullDocByType(id)
.subscribe(doc => {
var newTab = new GraphTab(this, null, doc);
newTab.nodes = doc.children;
// Filter the top level nodes if desired
if (filterTopLevelKeys) {
newTab.nodes = doc.children.filter(c => {
var rootKey = c.id.replace(/_/g, ''); // The 'all' structure has _, where the menu choice has those stripped. Remove them for comparison.
return filterTopLevelKeys.includes(rootKey);
});
}
// Override the tab name if desired
if (customName)
newTab.title = customName;
// Reference this data from the column view.
newTab.column.nodes = newTab.nodes;
this.graphTabs.push(newTab);
this.ensureISOIsInMiddle();
// Coverage calculation is disabled to save time.
//if (id != "ISO")
//{
// // compare with iso.
// newTab.coverage = this.compareDocs(newTab.column, this.graphTabs[1]);
//}
var selectTab = newTab;
if (newTab.isAll) {
selectTab = this.graphTabs.find(t => t.isIso);
}
// The current request is to NOT activate the newly added tab. So only activate index 0
if (this.graphTabs.length != 1) {
selectTab = this.graphTabs[this.selectedTab]; // reselect current selection
}
// even if we dont change tabs, we still have to reactive it to configure filters
this.activateTab(selectTab);
});
}
private ensureISOIsInMiddle() {
var isoTab = this.graphTabs.find(t => t.isIso);
if (this.graphTabs.length > 1)
{
this.graphTabs = this.graphTabs.filter(t => t != isoTab);
this.graphTabs.splice(1, 0, isoTab);
}
}
public configureFilterStack() {
switch (this.selectedTab)
{
case 0: this.filterOrder = [0, 1, 2]; break;
case 1: this.filterOrder = [1, 0, 2]; break;
case 2: this.filterOrder = [2, 1, 0]; break;
}
// setup filters
var isoTab = this.graphTabs.find(t => t.isIso);
var primary = this.graphTabs[this.filterOrder[0]];
if (!primary)
return;
// clear auto filter of left tab
primary.column.autoFilterSrc = null;
primary.column.autoFilterParent = null;
primary.column.autoFilterSelf = false;
var secondary = this.graphTabs[this.filterOrder[1]];
if (secondary)
{
if (secondary == isoTab)
{
// assure iso filters from the primary: "auto filter"
isoTab.column.autoFilterSrc = primary.column;
isoTab.column.autoFilterParent = primary.column.parent;
isoTab.column.autoFilterSelf = false;
}
else
{
// auto filter with this tabs connections to iso
secondary.column.autoFilterSrc = isoTab.column;
secondary.column.autoFilterParent = primary.column.parent; // the primary tab always drives the selection
secondary.column.autoFilterSelf = true;
}
}
var third = this.graphTabs[this.filterOrder[2]];
if (third)
{
// auto filter with this tabs connections to iso
third.column.autoFilterSrc = isoTab.column;
third.column.autoFilterParent = primary.column.parent; // the primary tab always drives the selection
third.column.autoFilterSelf = true;
}
}
public tabChanged() {
this.configureFilterStack();
if (this.selectedTab >= 0 && this.selectedTab < this.graphTabs.length) {
this.graphTabs[this.selectedTab].parentTabTreeChanged();
}
}
public removeTab(tab) {
this.graphTabs = this.graphTabs.filter(t => t!=tab);
this.ensureISOIsInMiddle();
this.activateTab(this.graphTabs[0]);
}
public activateTab(tab: GraphTab): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
var newIndex = this.graphTabs.indexOf(tab);
var finalize = () => {
this.selectedTab = newIndex;
this.tabChanged();
setTimeout(() => {
resolve(true);
}, 1000);
};
// if the index is the same
this.selectedTab = -1; // set it to non-value so change is detected
setTimeout(finalize, 1000); // give dom time to stabilize
});
}
public getNodesWithLinks(children: FullDocNode[], result: FullDocNode[])
{
for (var c of children)
{
if (c.node.links && c.node.links.length > 0)
result.push(c);
this.getNodesWithLinks(c.children, result);
}
return result;
}
public flattenSections(children: FullDocNode[], result: string[])
{
for (var c of children)
{
if (c.getBody())
result.push(c.id);
this.flattenSections(c.children, result);
}
return result;
}
public flattenLinks(children: FullDocNode[], result: Link | var t = tabs[i];
if (!t)
continue;
| random_line_split |
graph.service.ts | key.SankeyNode<SNodeExtra, SLinkExtra>;
export type SLink = d3Sankey.SankeyLink<SNodeExtra, SLinkExtra>;
export interface DAG {
nodes: SNode[];
links: SLink[];
}
// -- Dag Node --
@Injectable({ providedIn: 'root' })
export class GraphService {
private docGuids = {};
private docDb: Db = null;
private docs = {};
private nextDocGuid = 0;
private filterOrder = [];
private runningFilters = false;
public updateSubject = new Rx.BehaviorSubject(0);
public updateViewSubject = new Rx.BehaviorSubject(0);
public visualStyle = true;
public visualZoom = 1;
| (
private messageService: MessageService,
private http: HttpClient) {
this.addTab("ISO");
}
public runFilters(changedTab: GraphTab, parentChanged: boolean)
{
if (this.runningFilters)
return; // prevent re-entry
this.runningFilters = true;
var tabs = this.graphTabs;
var anyChanged = false;
for (var i of this.filterOrder)
{
var t = tabs[i];
if (!t)
continue;
if (anyChanged || t.column.autoFilterSrc == changedTab.column || (parentChanged && t == changedTab))
{
anyChanged = true;
// filter child tree
GraphFilter.runFilter(t.column);
}
}
//if (anyChanged)
this.updateSubject.next(0);
this.runningFilters = false;
}
getGuid(id: string, type: string, rev: string, createMissing: boolean = true): number {
var key = `${type}-${id}-${rev}`;
if (key in this.docGuids)
return this.docGuids[key];
if (!createMissing)
return null;
var value = this.nextDocGuid++;
this.docGuids[key] = value;
return value;
}
getDbIndex() : Observable<Db> {
if (this.docDb)
return of(this.docDb);
return this.http.get<Db>('assets/output/docs-index.json', {responseType: 'json'})
.pipe(
tap(
data => {
this.docDb = data;
},
error => this.handleError("getDbIndex", [])
)
);
}
getDoc(id: string) : Observable<Doc2> {
if (this.docs[id])
return of(this.docs[id]);
return this.http.get<Doc2>('assets/output/docs-' + id + '.json', {responseType: 'json'})
.pipe(
tap(
data => {
this.docs[id] = data;
},
error => this.handleError("getDoc", [])
)
);
}
getDocTypes() : Observable<CategoryList> {
return this.getDbIndex().pipe(
map(
data => {
return data.docs.map(v => { return { id: v.id, title: v.type }; });
}
)
);
}
private addToDoc(parent: FullDocNode, input: DocNode2) {
var child = new FullDocNode(input);
if (parent)
{
parent.children.push(child);
}
// Recurse
for (var c of input.children)
{
this.addToDoc(child, c);
}
return child;
}
getFullDocByType(id: string) : Observable<FullDocNode> {
return this.getDoc(id).pipe(
map(
data => {
return this.addToDoc(null, data);
}
)
);
}
getChangeLog(): Observable<Change[]> {
return this.getDbIndex().pipe(
map(
data => {
return data.changelog;
}
)
);
}
// Live state management: maybe move this to a different service.
public graphTabs: GraphTab[] = [ ];
public selectedTab: number = 0;
public get canAdd(): boolean {
return this.graphTabs.length < 3;
}
public addTab(id: string, filterTopLevelKeys: string[] = null, customName: string = null) {
if (!this.canAdd)
return;
this.getFullDocByType(id)
.subscribe(doc => {
var newTab = new GraphTab(this, null, doc);
newTab.nodes = doc.children;
// Filter the top level nodes if desired
if (filterTopLevelKeys) {
newTab.nodes = doc.children.filter(c => {
var rootKey = c.id.replace(/_/g, ''); // The 'all' structure has _, where the menu choice has those stripped. Remove them for comparison.
return filterTopLevelKeys.includes(rootKey);
});
}
// Override the tab name if desired
if (customName)
newTab.title = customName;
// Reference this data from the column view.
newTab.column.nodes = newTab.nodes;
this.graphTabs.push(newTab);
this.ensureISOIsInMiddle();
// Coverage calculation is disabled to save time.
//if (id != "ISO")
//{
// // compare with iso.
// newTab.coverage = this.compareDocs(newTab.column, this.graphTabs[1]);
//}
var selectTab = newTab;
if (newTab.isAll) {
selectTab = this.graphTabs.find(t => t.isIso);
}
// The current request is to NOT activate the newly added tab. So only activate index 0
if (this.graphTabs.length != 1) {
selectTab = this.graphTabs[this.selectedTab]; // reselect current selection
}
// even if we dont change tabs, we still have to reactive it to configure filters
this.activateTab(selectTab);
});
}
private ensureISOIsInMiddle() {
var isoTab = this.graphTabs.find(t => t.isIso);
if (this.graphTabs.length > 1)
{
this.graphTabs = this.graphTabs.filter(t => t != isoTab);
this.graphTabs.splice(1, 0, isoTab);
}
}
public configureFilterStack() {
switch (this.selectedTab)
{
case 0: this.filterOrder = [0, 1, 2]; break;
case 1: this.filterOrder = [1, 0, 2]; break;
case 2: this.filterOrder = [2, 1, 0]; break;
}
// setup filters
var isoTab = this.graphTabs.find(t => t.isIso);
var primary = this.graphTabs[this.filterOrder[0]];
if (!primary)
return;
// clear auto filter of left tab
primary.column.autoFilterSrc = null;
primary.column.autoFilterParent = null;
primary.column.autoFilterSelf = false;
var secondary = this.graphTabs[this.filterOrder[1]];
if (secondary)
{
if (secondary == isoTab)
{
// assure iso filters from the primary: "auto filter"
isoTab.column.autoFilterSrc = primary.column;
isoTab.column.autoFilterParent = primary.column.parent;
isoTab.column.autoFilterSelf = false;
}
else
{
// auto filter with this tabs connections to iso
secondary.column.autoFilterSrc = isoTab.column;
secondary.column.autoFilterParent = primary.column.parent; // the primary tab always drives the selection
secondary.column.autoFilterSelf = true;
}
}
var third = this.graphTabs[this.filterOrder[2]];
if (third)
{
// auto filter with this tabs connections to iso
third.column.autoFilterSrc = isoTab.column;
third.column.autoFilterParent = primary.column.parent; // the primary tab always drives the selection
third.column.autoFilterSelf = true;
}
}
public tabChanged() {
this.configureFilterStack();
if (this.selectedTab >= 0 && this.selectedTab < this.graphTabs.length) {
this.graphTabs[this.selectedTab].parentTabTreeChanged();
}
}
public removeTab(tab) {
this.graphTabs = this.graphTabs.filter(t => t!=tab);
this.ensureISOIsInMiddle();
this.activateTab(this.graphTabs[0]);
}
public activateTab(tab: GraphTab): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
var newIndex = this.graphTabs.indexOf(tab);
var finalize = () => {
this.selectedTab = newIndex;
this.tabChanged();
setTimeout(() => {
resolve(true);
}, 1000);
};
// if the index is the same
this.selectedTab = -1; // set it to non-value so change is detected
setTimeout(finalize, 1000); // give dom time to stabilize
});
}
public getNodesWithLinks(children: FullDocNode[], result: FullDocNode[])
{
for (var c of children)
{
if (c.node.links && c.node.links.length > 0)
result.push(c);
this.getNodesWithLinks(c.children, result);
}
return result;
}
public flattenSections(children: FullDocNode[], result: string[])
{
for (var c of children)
{
if (c.getBody())
result.push(c.id);
this.flattenSections(c.children, result);
}
return result;
}
public flattenLinks(children: FullDocNode[], result: Link | constructor | identifier_name |
graph.service.ts | , title: v.type }; });
}
)
);
}
private addToDoc(parent: FullDocNode, input: DocNode2) {
var child = new FullDocNode(input);
if (parent)
{
parent.children.push(child);
}
// Recurse
for (var c of input.children)
{
this.addToDoc(child, c);
}
return child;
}
getFullDocByType(id: string) : Observable<FullDocNode> {
return this.getDoc(id).pipe(
map(
data => {
return this.addToDoc(null, data);
}
)
);
}
getChangeLog(): Observable<Change[]> {
return this.getDbIndex().pipe(
map(
data => {
return data.changelog;
}
)
);
}
// Live state management: maybe move this to a different service.
public graphTabs: GraphTab[] = [ ];
public selectedTab: number = 0;
public get canAdd(): boolean {
return this.graphTabs.length < 3;
}
public addTab(id: string, filterTopLevelKeys: string[] = null, customName: string = null) {
if (!this.canAdd)
return;
this.getFullDocByType(id)
.subscribe(doc => {
var newTab = new GraphTab(this, null, doc);
newTab.nodes = doc.children;
// Filter the top level nodes if desired
if (filterTopLevelKeys) {
newTab.nodes = doc.children.filter(c => {
var rootKey = c.id.replace(/_/g, ''); // The 'all' structure has _, where the menu choice has those stripped. Remove them for comparison.
return filterTopLevelKeys.includes(rootKey);
});
}
// Override the tab name if desired
if (customName)
newTab.title = customName;
// Reference this data from the column view.
newTab.column.nodes = newTab.nodes;
this.graphTabs.push(newTab);
this.ensureISOIsInMiddle();
// Coverage calculation is disabled to save time.
//if (id != "ISO")
//{
// // compare with iso.
// newTab.coverage = this.compareDocs(newTab.column, this.graphTabs[1]);
//}
var selectTab = newTab;
if (newTab.isAll) {
selectTab = this.graphTabs.find(t => t.isIso);
}
// The current request is to NOT activate the newly added tab. So only activate index 0
if (this.graphTabs.length != 1) {
selectTab = this.graphTabs[this.selectedTab]; // reselect current selection
}
// even if we dont change tabs, we still have to reactive it to configure filters
this.activateTab(selectTab);
});
}
private ensureISOIsInMiddle() {
var isoTab = this.graphTabs.find(t => t.isIso);
if (this.graphTabs.length > 1)
{
this.graphTabs = this.graphTabs.filter(t => t != isoTab);
this.graphTabs.splice(1, 0, isoTab);
}
}
public configureFilterStack() {
switch (this.selectedTab)
{
case 0: this.filterOrder = [0, 1, 2]; break;
case 1: this.filterOrder = [1, 0, 2]; break;
case 2: this.filterOrder = [2, 1, 0]; break;
}
// setup filters
var isoTab = this.graphTabs.find(t => t.isIso);
var primary = this.graphTabs[this.filterOrder[0]];
if (!primary)
return;
// clear auto filter of left tab
primary.column.autoFilterSrc = null;
primary.column.autoFilterParent = null;
primary.column.autoFilterSelf = false;
var secondary = this.graphTabs[this.filterOrder[1]];
if (secondary)
{
if (secondary == isoTab)
{
// assure iso filters from the primary: "auto filter"
isoTab.column.autoFilterSrc = primary.column;
isoTab.column.autoFilterParent = primary.column.parent;
isoTab.column.autoFilterSelf = false;
}
else
{
// auto filter with this tabs connections to iso
secondary.column.autoFilterSrc = isoTab.column;
secondary.column.autoFilterParent = primary.column.parent; // the primary tab always drives the selection
secondary.column.autoFilterSelf = true;
}
}
var third = this.graphTabs[this.filterOrder[2]];
if (third)
{
// auto filter with this tabs connections to iso
third.column.autoFilterSrc = isoTab.column;
third.column.autoFilterParent = primary.column.parent; // the primary tab always drives the selection
third.column.autoFilterSelf = true;
}
}
public tabChanged() {
this.configureFilterStack();
if (this.selectedTab >= 0 && this.selectedTab < this.graphTabs.length) {
this.graphTabs[this.selectedTab].parentTabTreeChanged();
}
}
public removeTab(tab) {
this.graphTabs = this.graphTabs.filter(t => t!=tab);
this.ensureISOIsInMiddle();
this.activateTab(this.graphTabs[0]);
}
public activateTab(tab: GraphTab): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
var newIndex = this.graphTabs.indexOf(tab);
var finalize = () => {
this.selectedTab = newIndex;
this.tabChanged();
setTimeout(() => {
resolve(true);
}, 1000);
};
// if the index is the same
this.selectedTab = -1; // set it to non-value so change is detected
setTimeout(finalize, 1000); // give dom time to stabilize
});
}
public getNodesWithLinks(children: FullDocNode[], result: FullDocNode[])
{
for (var c of children)
{
if (c.node.links && c.node.links.length > 0)
result.push(c);
this.getNodesWithLinks(c.children, result);
}
return result;
}
public flattenSections(children: FullDocNode[], result: string[])
{
for (var c of children)
{
if (c.getBody())
result.push(c.id);
this.flattenSections(c.children, result);
}
return result;
}
public flattenLinks(children: FullDocNode[], result: Link[], linkData: any)
{
for (var c of children)
{
if (c.shouldBeMapped)
{
linkData.total++;
if (!c.isUnmapped)
{
linkData.linked++;
result = result.concat(c.node.links);
}
}
result = this.flattenLinks(c.children, result, linkData);
}
return result;
}
public compareDocs(aTab: GraphTab, bTab: GraphTab): any {
var bSections = [];
this.flattenSections(bTab.nodes, bSections);
var bCopy = bSections.slice();
var linkData = { total: 0, linked: 0 };
var aLinks = this.flattenLinks(aTab.nodes, [], linkData);
var found = 0;
var checked = 0;
for (var a of aLinks)
{
++checked;
var b = bCopy.find(x => x == a.id)
if (b)
{
bCopy = bCopy.filter(x => x != b);
++found;
}
}
return {
coverage: found + "/" + bSections.length,
mapped: linkData.linked + "/" + linkData.total,
uniqueconnections: found + "/" + checked,
uncoveredIds: bCopy
//"coverage": (found / bSections.length * 100).toFixed(1) + "% (" + found + "/" + bSections.length + ")",
//"mapped": (linkData.linked / linkData.total * 100).toFixed(1) + "% (" + linkData.linked + "/" + linkData.total + ")",
//"uniqueconnections": (found / checked * 100).toFixed(1) + "% (" + found + "/" + checked + ")"
};
}
/**
* Handle Http operation that failed.
* Let the app continue.
* @param operation - name of the operation that failed
* @param result - optional value to return as the observable result
*/
private handleError<T> (operation = 'operation', result?: T) {
return (error: any): Observable<T> => {
// TODO: send the error to remote logging infrastructure
console.error(error); // log to console instead
// TODO: better job of transforming error for user consumption
this.log(`${operation} failed: ${error.message}`);
// Let the app keep running by returning an empty result.
return of(result as T);
};
}
/** Log a GraphService message with the MessageService */
private log(message: string) {
this.messageService.add(`GraphService: ${message}`);
}
public get errorStrings(): string[] {
return this.graphTabs.reduce((a: string[], v: GraphTab) => { a.concat(v.errors()); return a; }, []);
}
public get anyErrors(): boolean | {
for (var t of this.graphTabs)
if (t.anyErrors)
return true;
return false;
} | identifier_body |
|
binomial.rs | algorithm based on the inverse
// transformation of the binomial distribution is efficient. Otherwise,
// the BTPE algorithm is used.
//
// Voratas Kachitvichyanukul and Bruce W. Schmeiser. 1988. Binomial
// random variate generation. Commun. ACM 31, 2 (February 1988),
// 216-222. http://dx.doi.org/10.1145/42372.42381
// Threshold for prefering the BINV algorithm. The paper suggests 10,
// Ranlib uses 30, and GSL uses 14.
const BINV_THRESHOLD: f64 = 10.;
if (self.n as f64) * p < BINV_THRESHOLD && self.n <= (::std::i32::MAX as u64) {
// Use the BINV algorithm.
let s = p / q;
let a = ((self.n + 1) as f64) * s;
let mut r = q.powi(self.n as i32);
let mut u: f64 = rng.gen();
let mut x = 0;
while u > r as f64 {
u -= r;
x += 1;
r *= a / (x as f64) - s;
}
result = x;
} else {
// Use the BTPE algorithm.
// Threshold for using the squeeze algorithm. This can be freely
// chosen based on performance. Ranlib and GSL use 20.
const SQUEEZE_THRESHOLD: i64 = 20;
// Step 0: Calculate constants as functions of `n` and `p`.
let n = self.n as f64;
let np = n * p;
let npq = np * q;
let f_m = np + p;
let m = f64_to_i64(f_m);
// radius of triangle region, since height=1 also area of region
let p1 = (2.195 * npq.sqrt() - 4.6 * q).floor() + 0.5;
// tip of triangle
let x_m = (m as f64) + 0.5;
// left edge of triangle
let x_l = x_m - p1;
// right edge of triangle
let x_r = x_m + p1;
let c = 0.134 + 20.5 / (15.3 + (m as f64));
// p1 + area of parallelogram region
let p2 = p1 * (1. + 2. * c);
fn lambda(a: f64) -> f64 {
a * (1. + 0.5 * a)
}
let lambda_l = lambda((f_m - x_l) / (f_m - x_l * p));
let lambda_r = lambda((x_r - f_m) / (x_r * q));
// p1 + area of left tail
let p3 = p2 + c / lambda_l;
// p1 + area of right tail
let p4 = p3 + c / lambda_r;
// return value
let mut y: i64;
let gen_u = Uniform::new(0., p4);
let gen_v = Uniform::new(0., 1.);
loop {
// Step 1: Generate `u` for selecting the region. If region 1 is
// selected, generate a triangularly distributed variate.
let u = gen_u.sample(rng);
let mut v = gen_v.sample(rng);
if !(u > p1) {
y = f64_to_i64(x_m - p1 * v + u);
break;
}
if !(u > p2) {
// Step 2: Region 2, parallelograms. Check if region 2 is
// used. If so, generate `y`.
let x = x_l + (u - p1) / c;
v = v * c + 1.0 - (x - x_m).abs() / p1;
if v > 1. {
continue;
} else {
y = f64_to_i64(x);
}
} else if !(u > p3) {
// Step 3: Region 3, left exponential tail.
y = f64_to_i64(x_l + v.ln() / lambda_l);
if y < 0 {
continue;
} else {
v *= (u - p2) * lambda_l;
}
} else {
// Step 4: Region 4, right exponential tail.
y = f64_to_i64(x_r - v.ln() / lambda_r);
if y > 0 && (y as u64) > self.n {
continue;
} else {
v *= (u - p3) * lambda_r;
}
}
// Step 5: Acceptance/rejection comparison.
// Step 5.0: Test for appropriate method of evaluating f(y).
let k = (y - m).abs();
if !(k > SQUEEZE_THRESHOLD && (k as f64) < 0.5 * npq - 1.) {
// Step 5.1: Evaluate f(y) via the recursive relationship. Start the
// search from the mode.
let s = p / q;
let a = s * (n + 1.);
let mut f = 1.0;
if m < y {
let mut i = m;
loop {
i += 1;
f *= a / (i as f64) - s;
if i == y {
break;
}
}
} else if m > y {
let mut i = y;
loop {
i += 1;
f /= a / (i as f64) - s;
if i == m {
break;
}
}
}
if v > f {
continue;
} else {
break;
}
}
// Step 5.2: Squeezing. Check the value of ln(v) againts upper and
// lower bound of ln(f(y)).
let k = k as f64;
let rho = (k / npq) * ((k * (k / 3. + 0.625) + 1. / 6.) / npq + 0.5);
let t = -0.5 * k * k / npq;
let alpha = v.ln();
if alpha < t - rho {
break;
}
if alpha > t + rho {
continue;
}
// Step 5.3: Final acceptance/rejection test.
let x1 = (y + 1) as f64;
let f1 = (m + 1) as f64;
let z = (f64_to_i64(n) + 1 - m) as f64;
let w = (f64_to_i64(n) - y + 1) as f64;
fn stirling(a: f64) -> f64 {
let a2 = a * a;
(13860. - (462. - (132. - (99. - 140. / a2) / a2) / a2) / a2) / a / 166320.
}
if alpha
> x_m * (f1 / x1).ln()
+ (n - (m as f64) + 0.5) * (z / w).ln()
+ ((y - m) as f64) * (w * p / (x1 * q)).ln()
// We use the signs from the GSL implementation, which are
// different than the ones in the reference. According to
// the GSL authors, the new signs were verified to be
// correct by one of the original designers of the
// algorithm.
+ stirling(f1)
+ stirling(z)
- stirling(x1)
- stirling(w)
{
continue;
}
break;
}
assert!(y >= 0);
result = y as u64;
}
// Invert the result for p < 0.5.
if p != self.p {
self.n - result
} else {
result
}
}
}
#[cfg(test)]
mod test {
use super::Binomial;
use crate::distributions::Distribution;
use crate::Rng;
fn test_binomial_mean_and_variance<R: Rng>(n: u64, p: f64, rng: &mut R) {
let binomial = Binomial::new(n, p);
let expected_mean = n as f64 * p;
let expected_variance = n as f64 * p * (1.0 - p);
| let mut results = [0.0; 1000]; | random_line_split |
|
binomial.rs | ;
} else if self.p == 1.0 {
return self.n;
}
// The binomial distribution is symmetrical with respect to p -> 1-p,
// k -> n-k switch p so that it is less than 0.5 - this allows for lower
// expected values we will just invert the result at the end
let p = if self.p <= 0.5 { self.p } else { 1.0 - self.p };
let result;
let q = 1. - p;
// For small n * min(p, 1 - p), the BINV algorithm based on the inverse
// transformation of the binomial distribution is efficient. Otherwise,
// the BTPE algorithm is used.
//
// Voratas Kachitvichyanukul and Bruce W. Schmeiser. 1988. Binomial
// random variate generation. Commun. ACM 31, 2 (February 1988),
// 216-222. http://dx.doi.org/10.1145/42372.42381
// Threshold for prefering the BINV algorithm. The paper suggests 10,
// Ranlib uses 30, and GSL uses 14.
const BINV_THRESHOLD: f64 = 10.;
if (self.n as f64) * p < BINV_THRESHOLD && self.n <= (::std::i32::MAX as u64) {
// Use the BINV algorithm.
let s = p / q;
let a = ((self.n + 1) as f64) * s;
let mut r = q.powi(self.n as i32);
let mut u: f64 = rng.gen();
let mut x = 0;
while u > r as f64 {
u -= r;
x += 1;
r *= a / (x as f64) - s;
}
result = x;
} else {
// Use the BTPE algorithm.
// Threshold for using the squeeze algorithm. This can be freely
// chosen based on performance. Ranlib and GSL use 20.
const SQUEEZE_THRESHOLD: i64 = 20;
// Step 0: Calculate constants as functions of `n` and `p`.
let n = self.n as f64;
let np = n * p;
let npq = np * q;
let f_m = np + p;
let m = f64_to_i64(f_m);
// radius of triangle region, since height=1 also area of region
let p1 = (2.195 * npq.sqrt() - 4.6 * q).floor() + 0.5;
// tip of triangle
let x_m = (m as f64) + 0.5;
// left edge of triangle
let x_l = x_m - p1;
// right edge of triangle
let x_r = x_m + p1;
let c = 0.134 + 20.5 / (15.3 + (m as f64));
// p1 + area of parallelogram region
let p2 = p1 * (1. + 2. * c);
fn lambda(a: f64) -> f64 {
a * (1. + 0.5 * a)
}
let lambda_l = lambda((f_m - x_l) / (f_m - x_l * p));
let lambda_r = lambda((x_r - f_m) / (x_r * q));
// p1 + area of left tail
let p3 = p2 + c / lambda_l;
// p1 + area of right tail
let p4 = p3 + c / lambda_r;
// return value
let mut y: i64;
let gen_u = Uniform::new(0., p4);
let gen_v = Uniform::new(0., 1.);
loop {
// Step 1: Generate `u` for selecting the region. If region 1 is
// selected, generate a triangularly distributed variate.
let u = gen_u.sample(rng);
let mut v = gen_v.sample(rng);
if !(u > p1) {
y = f64_to_i64(x_m - p1 * v + u);
break;
}
if !(u > p2) {
// Step 2: Region 2, parallelograms. Check if region 2 is
// used. If so, generate `y`.
let x = x_l + (u - p1) / c;
v = v * c + 1.0 - (x - x_m).abs() / p1;
if v > 1. {
continue;
} else {
y = f64_to_i64(x);
}
} else if !(u > p3) {
// Step 3: Region 3, left exponential tail.
y = f64_to_i64(x_l + v.ln() / lambda_l);
if y < 0 {
continue;
} else {
v *= (u - p2) * lambda_l;
}
} else {
// Step 4: Region 4, right exponential tail.
y = f64_to_i64(x_r - v.ln() / lambda_r);
if y > 0 && (y as u64) > self.n {
continue;
} else {
v *= (u - p3) * lambda_r;
}
}
// Step 5: Acceptance/rejection comparison.
// Step 5.0: Test for appropriate method of evaluating f(y).
let k = (y - m).abs();
if !(k > SQUEEZE_THRESHOLD && (k as f64) < 0.5 * npq - 1.) {
// Step 5.1: Evaluate f(y) via the recursive relationship. Start the
// search from the mode.
let s = p / q;
let a = s * (n + 1.);
let mut f = 1.0;
if m < y {
let mut i = m;
loop {
i += 1;
f *= a / (i as f64) - s;
if i == y {
break;
}
}
} else if m > y {
let mut i = y;
loop {
i += 1;
f /= a / (i as f64) - s;
if i == m {
break;
}
}
}
if v > f {
continue;
} else {
break;
}
}
// Step 5.2: Squeezing. Check the value of ln(v) againts upper and
// lower bound of ln(f(y)).
let k = k as f64;
let rho = (k / npq) * ((k * (k / 3. + 0.625) + 1. / 6.) / npq + 0.5);
let t = -0.5 * k * k / npq;
let alpha = v.ln();
if alpha < t - rho {
break;
}
if alpha > t + rho {
continue;
}
// Step 5.3: Final acceptance/rejection test.
let x1 = (y + 1) as f64;
let f1 = (m + 1) as f64;
let z = (f64_to_i64(n) + 1 - m) as f64;
let w = (f64_to_i64(n) - y + 1) as f64;
fn stirling(a: f64) -> f64 {
let a2 = a * a;
(13860. - (462. - (132. - (99. - 140. / a2) / a2) / a2) / a2) / a / 166320.
}
if alpha
> x_m * (f1 / x1).ln()
+ (n - (m as f64) + 0.5) * (z / w).ln()
+ ((y - m) as f64) * (w * p / (x1 * q)).ln()
// We use the signs from the GSL implementation, which are
// different than the ones in the reference. According to
// the GSL authors, the new signs were verified to be
// correct by one of the original designers of the
// algorithm.
+ stirling(f1)
+ stirling(z)
- stirling(x1)
- stirling(w)
{
continue;
}
break;
}
assert!(y >= 0);
result = y as u64;
}
// Invert the result for p < 0.5.
if p != self.p | {
self.n - result
} | conditional_block |
|
binomial.rs | 4) {
// Use the BINV algorithm.
let s = p / q;
let a = ((self.n + 1) as f64) * s;
let mut r = q.powi(self.n as i32);
let mut u: f64 = rng.gen();
let mut x = 0;
while u > r as f64 {
u -= r;
x += 1;
r *= a / (x as f64) - s;
}
result = x;
} else {
// Use the BTPE algorithm.
// Threshold for using the squeeze algorithm. This can be freely
// chosen based on performance. Ranlib and GSL use 20.
const SQUEEZE_THRESHOLD: i64 = 20;
// Step 0: Calculate constants as functions of `n` and `p`.
let n = self.n as f64;
let np = n * p;
let npq = np * q;
let f_m = np + p;
let m = f64_to_i64(f_m);
// radius of triangle region, since height=1 also area of region
let p1 = (2.195 * npq.sqrt() - 4.6 * q).floor() + 0.5;
// tip of triangle
let x_m = (m as f64) + 0.5;
// left edge of triangle
let x_l = x_m - p1;
// right edge of triangle
let x_r = x_m + p1;
let c = 0.134 + 20.5 / (15.3 + (m as f64));
// p1 + area of parallelogram region
let p2 = p1 * (1. + 2. * c);
fn lambda(a: f64) -> f64 {
a * (1. + 0.5 * a)
}
let lambda_l = lambda((f_m - x_l) / (f_m - x_l * p));
let lambda_r = lambda((x_r - f_m) / (x_r * q));
// p1 + area of left tail
let p3 = p2 + c / lambda_l;
// p1 + area of right tail
let p4 = p3 + c / lambda_r;
// return value
let mut y: i64;
let gen_u = Uniform::new(0., p4);
let gen_v = Uniform::new(0., 1.);
loop {
// Step 1: Generate `u` for selecting the region. If region 1 is
// selected, generate a triangularly distributed variate.
let u = gen_u.sample(rng);
let mut v = gen_v.sample(rng);
if !(u > p1) {
y = f64_to_i64(x_m - p1 * v + u);
break;
}
if !(u > p2) {
// Step 2: Region 2, parallelograms. Check if region 2 is
// used. If so, generate `y`.
let x = x_l + (u - p1) / c;
v = v * c + 1.0 - (x - x_m).abs() / p1;
if v > 1. {
continue;
} else {
y = f64_to_i64(x);
}
} else if !(u > p3) {
// Step 3: Region 3, left exponential tail.
y = f64_to_i64(x_l + v.ln() / lambda_l);
if y < 0 {
continue;
} else {
v *= (u - p2) * lambda_l;
}
} else {
// Step 4: Region 4, right exponential tail.
y = f64_to_i64(x_r - v.ln() / lambda_r);
if y > 0 && (y as u64) > self.n {
continue;
} else {
v *= (u - p3) * lambda_r;
}
}
// Step 5: Acceptance/rejection comparison.
// Step 5.0: Test for appropriate method of evaluating f(y).
let k = (y - m).abs();
if !(k > SQUEEZE_THRESHOLD && (k as f64) < 0.5 * npq - 1.) {
// Step 5.1: Evaluate f(y) via the recursive relationship. Start the
// search from the mode.
let s = p / q;
let a = s * (n + 1.);
let mut f = 1.0;
if m < y {
let mut i = m;
loop {
i += 1;
f *= a / (i as f64) - s;
if i == y {
break;
}
}
} else if m > y {
let mut i = y;
loop {
i += 1;
f /= a / (i as f64) - s;
if i == m {
break;
}
}
}
if v > f {
continue;
} else {
break;
}
}
// Step 5.2: Squeezing. Check the value of ln(v) againts upper and
// lower bound of ln(f(y)).
let k = k as f64;
let rho = (k / npq) * ((k * (k / 3. + 0.625) + 1. / 6.) / npq + 0.5);
let t = -0.5 * k * k / npq;
let alpha = v.ln();
if alpha < t - rho {
break;
}
if alpha > t + rho {
continue;
}
// Step 5.3: Final acceptance/rejection test.
let x1 = (y + 1) as f64;
let f1 = (m + 1) as f64;
let z = (f64_to_i64(n) + 1 - m) as f64;
let w = (f64_to_i64(n) - y + 1) as f64;
fn stirling(a: f64) -> f64 {
let a2 = a * a;
(13860. - (462. - (132. - (99. - 140. / a2) / a2) / a2) / a2) / a / 166320.
}
if alpha
> x_m * (f1 / x1).ln()
+ (n - (m as f64) + 0.5) * (z / w).ln()
+ ((y - m) as f64) * (w * p / (x1 * q)).ln()
// We use the signs from the GSL implementation, which are
// different than the ones in the reference. According to
// the GSL authors, the new signs were verified to be
// correct by one of the original designers of the
// algorithm.
+ stirling(f1)
+ stirling(z)
- stirling(x1)
- stirling(w)
{
continue;
}
break;
}
assert!(y >= 0);
result = y as u64;
}
// Invert the result for p < 0.5.
if p != self.p {
self.n - result
} else {
result
}
}
}
#[cfg(test)]
mod test {
use super::Binomial;
use crate::distributions::Distribution;
use crate::Rng;
fn test_binomial_mean_and_variance<R: Rng>(n: u64, p: f64, rng: &mut R) {
let binomial = Binomial::new(n, p);
let expected_mean = n as f64 * p;
let expected_variance = n as f64 * p * (1.0 - p);
let mut results = [0.0; 1000];
for i in results.iter_mut() {
*i = binomial.sample(rng) as f64;
}
let mean = results.iter().sum::<f64>() / results.len() as f64;
assert!(
(mean as f64 - expected_mean).abs() < expected_mean / 50.0,
"mean: {}, expected_mean: {}",
mean,
expected_mean
);
let variance =
results.iter().map(|x| (x - mean) * (x - mean)).sum::<f64>() / results.len() as f64;
assert!(
(variance - expected_variance).abs() < expected_variance / 10.0,
"variance: {}, expected_variance: {}",
variance,
expected_variance
);
}
#[test]
#[cfg_attr(miri, ignore)] // Miri is too slow
fn | test_binomial | identifier_name |
|
binomial.rs | ) -> Binomial {
assert!(p >= 0.0, "Binomial::new called with p < 0");
assert!(p <= 1.0, "Binomial::new called with p > 1");
Binomial { n, p }
}
}
/// Convert a `f64` to an `i64`, panicing on overflow.
// In the future (Rust 1.34), this might be replaced with `TryFrom`.
fn f64_to_i64(x: f64) -> i64 {
assert!(x < (::std::i64::MAX as f64));
x as i64
}
impl Distribution<u64> for Binomial {
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
// Handle these values directly.
if self.p == 0.0 {
return 0;
} else if self.p == 1.0 {
return self.n;
}
// The binomial distribution is symmetrical with respect to p -> 1-p,
// k -> n-k switch p so that it is less than 0.5 - this allows for lower
// expected values we will just invert the result at the end
let p = if self.p <= 0.5 { self.p } else { 1.0 - self.p };
let result;
let q = 1. - p;
// For small n * min(p, 1 - p), the BINV algorithm based on the inverse
// transformation of the binomial distribution is efficient. Otherwise,
// the BTPE algorithm is used.
//
// Voratas Kachitvichyanukul and Bruce W. Schmeiser. 1988. Binomial
// random variate generation. Commun. ACM 31, 2 (February 1988),
// 216-222. http://dx.doi.org/10.1145/42372.42381
// Threshold for prefering the BINV algorithm. The paper suggests 10,
// Ranlib uses 30, and GSL uses 14.
const BINV_THRESHOLD: f64 = 10.;
if (self.n as f64) * p < BINV_THRESHOLD && self.n <= (::std::i32::MAX as u64) {
// Use the BINV algorithm.
let s = p / q;
let a = ((self.n + 1) as f64) * s;
let mut r = q.powi(self.n as i32);
let mut u: f64 = rng.gen();
let mut x = 0;
while u > r as f64 {
u -= r;
x += 1;
r *= a / (x as f64) - s;
}
result = x;
} else {
// Use the BTPE algorithm.
// Threshold for using the squeeze algorithm. This can be freely
// chosen based on performance. Ranlib and GSL use 20.
const SQUEEZE_THRESHOLD: i64 = 20;
// Step 0: Calculate constants as functions of `n` and `p`.
let n = self.n as f64;
let np = n * p;
let npq = np * q;
let f_m = np + p;
let m = f64_to_i64(f_m);
// radius of triangle region, since height=1 also area of region
let p1 = (2.195 * npq.sqrt() - 4.6 * q).floor() + 0.5;
// tip of triangle
let x_m = (m as f64) + 0.5;
// left edge of triangle
let x_l = x_m - p1;
// right edge of triangle
let x_r = x_m + p1;
let c = 0.134 + 20.5 / (15.3 + (m as f64));
// p1 + area of parallelogram region
let p2 = p1 * (1. + 2. * c);
fn lambda(a: f64) -> f64 |
let lambda_l = lambda((f_m - x_l) / (f_m - x_l * p));
let lambda_r = lambda((x_r - f_m) / (x_r * q));
// p1 + area of left tail
let p3 = p2 + c / lambda_l;
// p1 + area of right tail
let p4 = p3 + c / lambda_r;
// return value
let mut y: i64;
let gen_u = Uniform::new(0., p4);
let gen_v = Uniform::new(0., 1.);
loop {
// Step 1: Generate `u` for selecting the region. If region 1 is
// selected, generate a triangularly distributed variate.
let u = gen_u.sample(rng);
let mut v = gen_v.sample(rng);
if !(u > p1) {
y = f64_to_i64(x_m - p1 * v + u);
break;
}
if !(u > p2) {
// Step 2: Region 2, parallelograms. Check if region 2 is
// used. If so, generate `y`.
let x = x_l + (u - p1) / c;
v = v * c + 1.0 - (x - x_m).abs() / p1;
if v > 1. {
continue;
} else {
y = f64_to_i64(x);
}
} else if !(u > p3) {
// Step 3: Region 3, left exponential tail.
y = f64_to_i64(x_l + v.ln() / lambda_l);
if y < 0 {
continue;
} else {
v *= (u - p2) * lambda_l;
}
} else {
// Step 4: Region 4, right exponential tail.
y = f64_to_i64(x_r - v.ln() / lambda_r);
if y > 0 && (y as u64) > self.n {
continue;
} else {
v *= (u - p3) * lambda_r;
}
}
// Step 5: Acceptance/rejection comparison.
// Step 5.0: Test for appropriate method of evaluating f(y).
let k = (y - m).abs();
if !(k > SQUEEZE_THRESHOLD && (k as f64) < 0.5 * npq - 1.) {
// Step 5.1: Evaluate f(y) via the recursive relationship. Start the
// search from the mode.
let s = p / q;
let a = s * (n + 1.);
let mut f = 1.0;
if m < y {
let mut i = m;
loop {
i += 1;
f *= a / (i as f64) - s;
if i == y {
break;
}
}
} else if m > y {
let mut i = y;
loop {
i += 1;
f /= a / (i as f64) - s;
if i == m {
break;
}
}
}
if v > f {
continue;
} else {
break;
}
}
// Step 5.2: Squeezing. Check the value of ln(v) againts upper and
// lower bound of ln(f(y)).
let k = k as f64;
let rho = (k / npq) * ((k * (k / 3. + 0.625) + 1. / 6.) / npq + 0.5);
let t = -0.5 * k * k / npq;
let alpha = v.ln();
if alpha < t - rho {
break;
}
if alpha > t + rho {
continue;
}
// Step 5.3: Final acceptance/rejection test.
let x1 = (y + 1) as f64;
let f1 = (m + 1) as f64;
let z = (f64_to_i64(n) + 1 - m) as f64;
let w = (f64_to_i64(n) - y + 1) as f64;
fn stirling(a: f64) -> f64 {
let a2 = a * a;
(13860. - (462. - (132. - (99. - 140. / a2) / a2) / a2) / a2) / a / 166320.
}
if alpha
> x_m * | {
a * (1. + 0.5 * a)
} | identifier_body |
main.rs | (
game: &Arc<RwLock<Game>>,
user_id: usize,
msg: WsMsg,
tx: &mpsc::UnboundedSender<WsMsg>
) -> Result<()> {
match msg {
WsMsg::Login(username) => {
if game.read().await.players.len() >= MAX_N_PLAYERS {
tx.send(WsMsg::LoginRejected(LoginRejectedReason::GameIsFull))?;
return Ok(())
}
if game.read().await.players.values().any(|player| player.name == username) {
tx.send(WsMsg::LoginRejected(LoginRejectedReason::UsernameIsTaken))?;
return Ok(())
}
tx.send(WsMsg::LoginAccepted)?;
let hand = game.write().await.answers.draw(N_CARDS_IN_HAND);
let player = Player {
name: username.clone(),
hand: hand.clone(),
score: 0,
};
game.write().await.players.insert(user_id, player);
// Notify other players
game.write().await.broadcast_to_players(&WsMsg::PlayerJoined { name: username })?;
// Only start new round if there are enough players
if game.read().await.players.len() >= MIN_N_PLAYERS {
let game = &mut game.write().await;
let round = if let Some(round) = &game.round {
round
} else {
// TODO lobby
println!("Starting new round");
game.new_round()?;
game.round.as_ref().unwrap()
};
// If in judgement, don't send NewRound
if round.state == RoundState::Answering {
let role = if round.czar == user_id { Role::Czar } else { Role::Player };
tx.send(WsMsg::NewRound {
role,
prompt: round.prompt.clone(),
hand: hand,
})?;
}
}
Ok(())
},
// WsMsg::Register(name) => todo!(),
// WsMsg::Ready => todo!(),
// WsMsg::NotReady => todo!(),
WsMsg::SubmitAnswer(answers) => {
if let Game {
clients,
players,
round: Some(round),
..
} = &mut *game.write().await {
if round.state != RoundState::Answering {
eprintln!("invalid query SubmitAnswer: round is in judgement phase");
return Ok(())
}
if round.czar == user_id {
eprintln!("invalid query SubmitAnswer: player is Czar");
return Ok(())
}
match round.answers.entry(user_id) {
hash_map::Entry::Occupied(_) => {
eprintln!("invalid query SubmitAnswer: player already submitted answer")
},
hash_map::Entry::Vacant(entry) => {
let hand = &mut players.get_mut(&user_id).unwrap().hand;
if !answers.iter().all(|x| hand.contains(x)) {
eprintln!("invalid query SubmitAnswer: cards are not in player's deck");
return Ok(())
}
println!("SubmitAnswer({})", answers.iter().map(Answer::to_string).collect::<Vec<_>>().join(", "));
// Remove cards from player's hand
hand.retain(|x| !answers.contains(x));
// Insert cards into submitted answers
entry.insert(answers);
tx.send(WsMsg::AnswerAccepted)?;
},
}
// Check whether all players have answered
if round.answers.len() == players.len() - 1 {
round.state = RoundState::Judging;
// If so, notify them that JUDGEMENT HAS BEGUN
// TODO maybe obfuscate the player IDs before sending
for id in players.keys() {
clients[id].send(WsMsg::ReadyToJudge(round.answers.clone()))?;
}
}
} else {
eprintln!("invalid query SubmitAnswer: there is no ongoing round");
}
// TODO send AnswerAccepted/Rejected messages
Ok(())
},
WsMsg::SubmitJudgement(answer_id) => {
let mut new_round = false;
if let Game {
clients,
players,
round: Some(round),
..
} = &mut *game.write().await {
if round.state != RoundState::Judging {
eprintln!("invalid query SubmitAnswer: round is in judgement phase");
return Ok(())
}
if round.czar != user_id {
eprintln!("invalid query SubmitJudgement: player isn't Czar");
return Ok(())
}
match round.answers.get(&answer_id) {
None => {
eprintln!("invalid query SubmitJudgement: user ID does not exist");
},
Some(winning_answers) => {
let winner = {
// Increment winner's scores
let winner = players.get_mut(&answer_id).unwrap();
winner.score += 1;
// Get winner's name
winner.name.clone()
};
let scores = players.values().map(|player| (player.name.clone(), player.score)).collect();
let msg = WsMsg::RoundEnded {
winner,
winning_answers: winning_answers.clone(),
scores,
};
// Notify end of round, provide winner and scores
for id in players.keys() {
clients[id].send(msg.clone())?;
}
new_round = true;
}
}
} else {
eprintln!("invalid query SubmitAnswer: there is no ongoing round");
}
if new_round {
game.write().await.new_round()?;
}
// TODO send JudgementAccepted/Rejected messages
Ok(())
},
_ => unreachable!(),
}
}
async fn user_connected(game: Arc<RwLock<Game>>, socket: WebSocket) {
let my_id = NEXT_USER_ID.fetch_add(1, Ordering::Relaxed);
println!("User connected: #{}", my_id);
let (tx, mut rx) = socket.split();
// Manage outgoing messages to this user
let tx = {
let (tx2, rx) = mpsc::unbounded_channel();
tokio::task::spawn(rx.map(|msg| {
Ok(Message::text(serde_json::to_string(&msg).unwrap()))
}).forward(tx).map(move |result| {
if let Err(e) = result {
eprintln!("websocket send error: {}", e);
}
}));
tx2
};
game.write().await.clients.insert(my_id, tx.clone());
// Manage incoming messages from this user
while let Some(result) = rx.next().await {
let msg = match result {
Ok(msg) => msg,
Err(e) => {
eprintln!("websocket error with user {}: {}", my_id, e);
break;
}
};
if let Ok(text) = msg.to_str() {
if let Ok(response) = serde_json::from_str::<WsMsg>(text) {
if let Err(_) = process_message(&game, my_id, response, &tx).await {
eprintln!("Error while processing message from player #{}", my_id);
break;
}
} else {
eprintln!("cannot read message");
}
}
}
println!("Client #{} disconnected", my_id);
user_disconnected(game, my_id).await;
}
async fn user_disconnected(game: Arc<RwLock<Game>>, user_id: usize) {
let game = &mut *game.write().await;
game.clients.remove(&user_id);
if let Some(player) = game.players.remove(&user_id) {
// Discard player's answers
game.answers.discard(&player.hand);
// Discard player's submitted answers, if any
let mut user_is_czar = false;
if let Game {
answers,
round: Some(Round { answers: submitted_answers, czar, .. }),
..
} = game {
if let Some(cards) = submitted_answers.remove(&user_id) {
answers.discard(&cards);
}
user_is_czar = *czar == user_id;
}
// If player is Czar, return submitted answers to owners and restart round
if user_is_czar {
let mut round = game.round.take().unwrap();
game.prompts.discard(&[round.prompt]);
for (id, player) in game.players.iter_mut() {
player.hand.extend(round.answers.remove(id).into_iter().flatten());
}
if game.players.len() > 0 {
game.new_round().expect("Couldn't start new round");
}
}
// Notify other players
game.broadcast_to_players(&WsMsg::PlayerLeft { name: player.name.clone() });
}
// If not enough players, cancel round
if game.players.len() < MIN_N_PLAYERS {
game.round = None;
game.answers.reset();
game.prompts.reset();
for id in game.players.keys() {
game.clients[id].send(WsMsg::GameEnded);
}
// Clear player hands, to avoid double-discard
for player in game.players.values_mut() {
player.hand.clear();
}
}
}
use ron;
use std::fs::File;
use serde::de::DeserializeOwned;
fn | load_deck | identifier_name |
|
main.rs | #{}", round.czar);
// Distribute cards and notify players
self.distribute_cards();
for (id, player) in &mut self.players {
let role = if *id == round.czar { Role::Czar } else { Role::Player };
self.clients[id].send(WsMsg::NewRound {
role,
prompt: round.prompt.clone(),
hand: player.hand.clone(),
})?;
}
// Set new round
self.round = Some(round);
Ok(())
}
fn broadcast_to_players(&mut self, msg: &WsMsg) -> Result<()> {
for id in self.players.keys() {
self.clients[id].send(msg.clone())?;
}
Ok(())
}
}
#[derive(PartialEq)]
enum RoundState {
Answering,
Judging,
}
struct Round {
prompt: Prompt,
czar: usize,
answers: HashMap<usize, Vec<Answer>>,
state: RoundState,
}
struct Player {
name: String,
hand: Vec<Answer>,
score: u64,
}
static NEXT_USER_ID: AtomicUsize = AtomicUsize::new(1);
async fn process_message(
game: &Arc<RwLock<Game>>,
user_id: usize,
msg: WsMsg,
tx: &mpsc::UnboundedSender<WsMsg>
) -> Result<()> {
match msg {
WsMsg::Login(username) => {
if game.read().await.players.len() >= MAX_N_PLAYERS {
tx.send(WsMsg::LoginRejected(LoginRejectedReason::GameIsFull))?;
return Ok(())
}
if game.read().await.players.values().any(|player| player.name == username) {
tx.send(WsMsg::LoginRejected(LoginRejectedReason::UsernameIsTaken))?;
return Ok(())
}
tx.send(WsMsg::LoginAccepted)?;
let hand = game.write().await.answers.draw(N_CARDS_IN_HAND);
let player = Player {
name: username.clone(),
hand: hand.clone(),
score: 0,
};
game.write().await.players.insert(user_id, player);
// Notify other players
game.write().await.broadcast_to_players(&WsMsg::PlayerJoined { name: username })?;
// Only start new round if there are enough players
if game.read().await.players.len() >= MIN_N_PLAYERS {
let game = &mut game.write().await;
let round = if let Some(round) = &game.round {
round
} else {
// TODO lobby
println!("Starting new round");
game.new_round()?;
game.round.as_ref().unwrap()
};
// If in judgement, don't send NewRound
if round.state == RoundState::Answering {
let role = if round.czar == user_id { Role::Czar } else { Role::Player };
tx.send(WsMsg::NewRound {
role,
prompt: round.prompt.clone(),
hand: hand,
})?;
}
}
Ok(())
},
// WsMsg::Register(name) => todo!(),
// WsMsg::Ready => todo!(),
// WsMsg::NotReady => todo!(),
WsMsg::SubmitAnswer(answers) => {
if let Game {
clients,
players,
round: Some(round),
..
} = &mut *game.write().await {
if round.state != RoundState::Answering {
eprintln!("invalid query SubmitAnswer: round is in judgement phase");
return Ok(())
}
if round.czar == user_id {
eprintln!("invalid query SubmitAnswer: player is Czar");
return Ok(())
}
match round.answers.entry(user_id) {
hash_map::Entry::Occupied(_) => {
eprintln!("invalid query SubmitAnswer: player already submitted answer")
},
hash_map::Entry::Vacant(entry) => {
let hand = &mut players.get_mut(&user_id).unwrap().hand;
if !answers.iter().all(|x| hand.contains(x)) {
eprintln!("invalid query SubmitAnswer: cards are not in player's deck");
return Ok(())
}
println!("SubmitAnswer({})", answers.iter().map(Answer::to_string).collect::<Vec<_>>().join(", "));
// Remove cards from player's hand
hand.retain(|x| !answers.contains(x));
// Insert cards into submitted answers
entry.insert(answers);
tx.send(WsMsg::AnswerAccepted)?;
},
}
// Check whether all players have answered
if round.answers.len() == players.len() - 1 {
round.state = RoundState::Judging;
// If so, notify them that JUDGEMENT HAS BEGUN
// TODO maybe obfuscate the player IDs before sending
for id in players.keys() {
clients[id].send(WsMsg::ReadyToJudge(round.answers.clone()))?;
}
}
} else {
eprintln!("invalid query SubmitAnswer: there is no ongoing round");
}
// TODO send AnswerAccepted/Rejected messages
Ok(())
},
WsMsg::SubmitJudgement(answer_id) => {
let mut new_round = false;
if let Game {
clients,
players,
round: Some(round),
..
} = &mut *game.write().await {
if round.state != RoundState::Judging {
eprintln!("invalid query SubmitAnswer: round is in judgement phase");
return Ok(())
}
if round.czar != user_id {
eprintln!("invalid query SubmitJudgement: player isn't Czar");
return Ok(())
}
match round.answers.get(&answer_id) {
None => {
eprintln!("invalid query SubmitJudgement: user ID does not exist");
},
Some(winning_answers) => {
let winner = {
// Increment winner's scores
let winner = players.get_mut(&answer_id).unwrap();
winner.score += 1;
// Get winner's name
winner.name.clone()
};
let scores = players.values().map(|player| (player.name.clone(), player.score)).collect();
let msg = WsMsg::RoundEnded {
winner,
winning_answers: winning_answers.clone(),
scores,
};
// Notify end of round, provide winner and scores
for id in players.keys() {
clients[id].send(msg.clone())?;
}
new_round = true;
}
}
} else {
eprintln!("invalid query SubmitAnswer: there is no ongoing round");
}
if new_round {
game.write().await.new_round()?;
}
// TODO send JudgementAccepted/Rejected messages
Ok(())
},
_ => unreachable!(),
}
}
async fn user_connected(game: Arc<RwLock<Game>>, socket: WebSocket) {
let my_id = NEXT_USER_ID.fetch_add(1, Ordering::Relaxed);
println!("User connected: #{}", my_id);
let (tx, mut rx) = socket.split();
// Manage outgoing messages to this user
let tx = {
let (tx2, rx) = mpsc::unbounded_channel();
tokio::task::spawn(rx.map(|msg| {
Ok(Message::text(serde_json::to_string(&msg).unwrap()))
}).forward(tx).map(move |result| {
if let Err(e) = result {
eprintln!("websocket send error: {}", e);
}
}));
tx2
};
game.write().await.clients.insert(my_id, tx.clone());
// Manage incoming messages from this user
while let Some(result) = rx.next().await {
let msg = match result {
Ok(msg) => msg,
Err(e) => {
eprintln!("websocket error with user {}: {}", my_id, e);
break;
}
};
if let Ok(text) = msg.to_str() {
if let Ok(response) = serde_json::from_str::<WsMsg>(text) {
if let Err(_) = process_message(&game, my_id, response, &tx).await {
eprintln!("Error while processing message from player #{}", my_id);
break;
}
} else {
eprintln!("cannot read message");
}
}
}
println!("Client #{} disconnected", my_id);
user_disconnected(game, my_id).await;
}
async fn user_disconnected(game: Arc<RwLock<Game>>, user_id: usize) | {
let game = &mut *game.write().await;
game.clients.remove(&user_id);
if let Some(player) = game.players.remove(&user_id) {
// Discard player's answers
game.answers.discard(&player.hand);
// Discard player's submitted answers, if any
let mut user_is_czar = false;
if let Game {
answers,
round: Some(Round { answers: submitted_answers, czar, .. }),
..
} = game {
if let Some(cards) = submitted_answers.remove(&user_id) {
answers.discard(&cards);
}
user_is_czar = *czar == user_id;
} | identifier_body |
|
main.rs | }
// Find next czar
let mut player_ids = self.players.keys().collect::<Vec<_>>();
player_ids.sort_unstable();
if let Err(idx) = player_ids.binary_search(&&next_czar) {
// There's no player with ID next_czar
if idx == player_ids.len() {
// There isn't a greater key
next_czar = *player_ids[0];
} else {
// There is a key greater than next_czar
next_czar = *player_ids[idx];
}
}
// Create new round
println!("Players to choose from: {:?}", self.players.keys().map(|u| u.to_string()).collect::<Vec<_>>().join(", "));
let round = Round {
prompt: self.prompts.draw_once(),
// TODO cycle Czars
czar: next_czar,
answers: Default::default(),
state: RoundState::Answering,
};
println!("Next czar is Player #{}", round.czar);
// Distribute cards and notify players
self.distribute_cards();
for (id, player) in &mut self.players {
let role = if *id == round.czar { Role::Czar } else { Role::Player };
self.clients[id].send(WsMsg::NewRound {
role,
prompt: round.prompt.clone(),
hand: player.hand.clone(),
})?;
}
// Set new round
self.round = Some(round);
Ok(())
}
fn broadcast_to_players(&mut self, msg: &WsMsg) -> Result<()> {
for id in self.players.keys() {
self.clients[id].send(msg.clone())?;
}
Ok(())
}
}
#[derive(PartialEq)]
enum RoundState {
Answering,
Judging,
}
struct Round {
prompt: Prompt,
czar: usize,
answers: HashMap<usize, Vec<Answer>>,
state: RoundState,
}
struct Player {
name: String,
hand: Vec<Answer>,
score: u64,
}
static NEXT_USER_ID: AtomicUsize = AtomicUsize::new(1);
async fn process_message(
game: &Arc<RwLock<Game>>,
user_id: usize,
msg: WsMsg,
tx: &mpsc::UnboundedSender<WsMsg>
) -> Result<()> {
match msg {
WsMsg::Login(username) => {
if game.read().await.players.len() >= MAX_N_PLAYERS {
tx.send(WsMsg::LoginRejected(LoginRejectedReason::GameIsFull))?;
return Ok(())
}
if game.read().await.players.values().any(|player| player.name == username) {
tx.send(WsMsg::LoginRejected(LoginRejectedReason::UsernameIsTaken))?;
return Ok(())
}
tx.send(WsMsg::LoginAccepted)?;
let hand = game.write().await.answers.draw(N_CARDS_IN_HAND);
let player = Player {
name: username.clone(),
hand: hand.clone(),
score: 0,
};
game.write().await.players.insert(user_id, player);
// Notify other players
game.write().await.broadcast_to_players(&WsMsg::PlayerJoined { name: username })?;
// Only start new round if there are enough players
if game.read().await.players.len() >= MIN_N_PLAYERS {
let game = &mut game.write().await;
let round = if let Some(round) = &game.round {
round
} else {
// TODO lobby
println!("Starting new round");
game.new_round()?;
game.round.as_ref().unwrap()
};
// If in judgement, don't send NewRound
if round.state == RoundState::Answering {
let role = if round.czar == user_id { Role::Czar } else { Role::Player };
tx.send(WsMsg::NewRound {
role,
prompt: round.prompt.clone(),
hand: hand,
})?;
}
}
Ok(())
},
// WsMsg::Register(name) => todo!(),
// WsMsg::Ready => todo!(),
// WsMsg::NotReady => todo!(),
WsMsg::SubmitAnswer(answers) => {
if let Game {
clients,
players,
round: Some(round),
..
} = &mut *game.write().await {
if round.state != RoundState::Answering {
eprintln!("invalid query SubmitAnswer: round is in judgement phase");
return Ok(())
}
if round.czar == user_id {
eprintln!("invalid query SubmitAnswer: player is Czar");
return Ok(())
}
match round.answers.entry(user_id) {
hash_map::Entry::Occupied(_) => {
eprintln!("invalid query SubmitAnswer: player already submitted answer")
},
hash_map::Entry::Vacant(entry) => {
let hand = &mut players.get_mut(&user_id).unwrap().hand;
if !answers.iter().all(|x| hand.contains(x)) {
eprintln!("invalid query SubmitAnswer: cards are not in player's deck");
return Ok(())
}
println!("SubmitAnswer({})", answers.iter().map(Answer::to_string).collect::<Vec<_>>().join(", "));
// Remove cards from player's hand
hand.retain(|x| !answers.contains(x));
// Insert cards into submitted answers
entry.insert(answers);
tx.send(WsMsg::AnswerAccepted)?; | },
}
// Check whether all players have answered
if round.answers.len() == players.len() - 1 {
round.state = RoundState::Judging;
// If so, notify them that JUDGEMENT HAS BEGUN
// TODO maybe obfuscate the player IDs before sending
for id in players.keys() {
clients[id].send(WsMsg::ReadyToJudge(round.answers.clone()))?;
}
}
} else {
eprintln!("invalid query SubmitAnswer: there is no ongoing round");
}
// TODO send AnswerAccepted/Rejected messages
Ok(())
},
WsMsg::SubmitJudgement(answer_id) => {
let mut new_round = false;
if let Game {
clients,
players,
round: Some(round),
..
} = &mut *game.write().await {
if round.state != RoundState::Judging {
eprintln!("invalid query SubmitAnswer: round is in judgement phase");
return Ok(())
}
if round.czar != user_id {
eprintln!("invalid query SubmitJudgement: player isn't Czar");
return Ok(())
}
match round.answers.get(&answer_id) {
None => {
eprintln!("invalid query SubmitJudgement: user ID does not exist");
},
Some(winning_answers) => {
let winner = {
// Increment winner's scores
let winner = players.get_mut(&answer_id).unwrap();
winner.score += 1;
// Get winner's name
winner.name.clone()
};
let scores = players.values().map(|player| (player.name.clone(), player.score)).collect();
let msg = WsMsg::RoundEnded {
winner,
winning_answers: winning_answers.clone(),
scores,
};
// Notify end of round, provide winner and scores
for id in players.keys() {
clients[id].send(msg.clone())?;
}
new_round = true;
}
}
} else {
eprintln!("invalid query SubmitAnswer: there is no ongoing round");
}
if new_round {
game.write().await.new_round()?;
}
// TODO send JudgementAccepted/Rejected messages
Ok(())
},
_ => unreachable!(),
}
}
async fn user_connected(game: Arc<RwLock<Game>>, socket: WebSocket) {
let my_id = NEXT_USER_ID.fetch_add(1, Ordering::Relaxed);
println!("User connected: #{}", my_id);
let (tx, mut rx) = socket.split();
// Manage outgoing messages to this user
let tx = {
let (tx2, rx) = mpsc::unbounded_channel();
tokio::task::spawn(rx.map(|msg| {
Ok(Message::text(serde_json::to_string(&msg).unwrap()))
}).forward(tx).map(move |result| {
if let Err(e) = result {
eprintln!("websocket send error: {}", e);
}
}));
tx2
};
game.write().await.clients.insert(my_id, tx.clone());
// Manage incoming messages from this user
while let Some(result) = rx.next().await {
let msg = match result {
Ok(msg) => msg,
Err(e) => {
eprintln!("websocket error with user {}: {}", my_id, e);
break;
}
};
if let Ok(text) = msg.to_str() {
if let Ok(response) = serde_json::from_str::<WsMsg>(text) {
if let Err(_) = process_message(&game, my_id, response, &tx).await {
eprintln!("Error while processing message | random_line_split |
|
cougballoon_rcv.py | , 'Hours':RMChours, 'Minutes':RMCminutes, 'Seconds':RMCseconds},'External temperature(deg F)':extTemp, 'Internal temperature(deg F)':intTemp, 'Video Transmitter temperature(deg F)':vidTemp, 'Carbon Monoxide level(ppm)':COlevel, 'Methane level(ppm)':CH4level, 'HackHD camera statuses':HackStatus } ]
data_string = json.dumps(JSONdata)
JSONdataString = str(data_string)
newJSONdata = re.match(r'\[(.*)', JSONdataString)
newJSONdata2 = "," + newJSONdata.group(1)
f = open('/Users/michaelhamilton/Desktop/json_data.html', 'r+')
jumpBack = -1 #jump back 1 spot from the end
f.seek(jumpBack, 2) #2 is the end of the file
last = f.readline() #read the last line
while (last != "]"): #if it's not a ], then keep jumping back
jumpBack = jumpBack - 1 #decrement
if (last == "]"):
f.seek(-1, 2)
f.write(newJSONdata2)
f.close()
#Send it to the server
os.system("cd /Users/michaelhamilton/Desktop && scp json_data.html [email protected]:Sites/")
print "Updated JSON information was sent to the server."
return
#Parse out the data from an RMC nmea string
def RegExprNMEAdataRMC(line):
#if it's an RMC string....
print line
newRMCline = re.match( r'\$GPRMC,(\d\d)(\d\d)(\d\d).*,\D,(\d+.\d+),\D,(\d+.\d+),\D,(\d+.\d+),(\d+.\d+),(\d\d)(\d\d)(\d\d),.*,.*', line, re.I)
#All data are strings, not integers
if (newRMCline):
global RMChours
RMChours = newRMCline.group(1)
#Convert UTC hours to PST(Daylight Savings Time)
RMChours = UTCtoPSTDST(RMChours)
global RMCminutes
RMCminutes = newRMCline.group(2)
global RMCseconds
RMCseconds = newRMCline.group(3)
global RMClatitude
RMClatitude = newRMCline.group(4)
RMClatitude = StringToFloatGPS(RMClatitude)
global RMClongitude
RMClongitude = newRMCline.group(5)
RMClongitude = StringToFloatGPS(RMClongitude)
global RMCspeed
RMCspeed = newRMCline.group(6)
RMCspeed = StringToFloatGPS(RMCspeed)
global RMCheading
RMCheading = newRMCline.group(7)
RMCheading = StringToFloatGPS(RMCheading)
global RMCday
RMCday = newRMCline.group(8)
global RMCmonth
RMCmonth = newRMCline.group(9)
global RMCyear
RMCyear = newRMCline.group(10)
return True
else:
return False
#Parse out the data from an GGA nmea string
def RegExprNMEAdataGGA(line):
#if it's a GGA string....
print line
newGGAline = re.match( r'\$GPGGA,(\d\d)(\d\d)(\d\d).*,(.*..*),\D,(.*..*),\D,\d,\d\d\,\d.\d\d,(\d+.\d),\D.*', line, re.I)
#All data are strings, not integers
if (newGGAline):
global GGAhours
GGAhours = newGGAline.group(1)
#Convert UTC hours to PST(Daylight Savings Time)
GGAhours = UTCtoPSTDST(GGAhours)
global GGAminutes
GGAminutes = newGGAline.group(2)
global GGAseconds
GGAseconds = newGGAline.group(3)
global GGAlatitude
GGAlatitude = newGGAline.group(4)
GGAlatitude = StringToFloatGPS(GGAlatitude)
global GGAlongitude
GGAlongitude = newGGAline.group(5)
GGAlongitude = StringToFloatGPS(GGAlongitude)
global GGAaltitude
GGAaltitude = newGGAline.group(6)
GGAaltitude = StringToFloatGPS(GGAaltitude)
s2.write(dict(x=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f'), y=GGAaltitude))
return True
else:
return False
#Get my login and keys ready ro send data to plot.ly
stream_ids = tls.get_credentials_file()['stream_ids']
#Set up the plotly streams
stream_id1 = stream_ids[0]#External temperature #A
stream_id2 = stream_ids[1]#GGAaltitude #B
stream_id3 = stream_ids[2]#Internal temperature #C
#stream_id4 = stream_ids[3]#Internal pressure #D
stream_id4 = stream_ids[3]#pressureAltitude #D
#stream_id5 = stream_ids[4]#Videolynx temperature #E
stream_id5 = stream_ids[4]#10DOF temperature #E
stream_id6 = stream_ids[5]#CO level in ppm #F
stream_id7 = stream_ids[6]#CH4 level in ppm #G
stream_id8 = stream_ids[7]#Humidity #J
stream_id9 = stream_ids[8]#Roll #L
stream_id10 = stream_ids[9]#Pitch #P
#stream_id11 = stream_ids[10]#Heading #Q
#stream_id12 = stream_ids[11]#Pressure #T
stream_id13 = stream_ids[12]#PressureAltitude #U
#Graph 1 data, stream names coincide with stream_ids for simplicity
#External temperature #A
stream1 = Stream(
token=stream_id1,
maxpoints=20
)
#GGAaltitude #A
stream2 = Stream(
token=stream_id2,
maxpoints=4
)
#Internal temperature #C
stream3 = Stream(
token=stream_id3,
maxpoints=20
)
#pressureAltitude #C
stream4 = Stream(
token=stream_id4,
maxpoints=20
)
#10DOF temperature #E
stream5 = Stream(
token=stream_id5,
maxpoints=20
)
#Graph 2 data, stream names coincide with stream_ids for simplicity
#CO level in ppm #G
stream6 = Stream(
token=stream_id6,
maxpoints=20
)
#CH4 level in ppm #G
stream7 = Stream(
token=stream_id7,
maxpoints=20
)
#Roll #L
stream9 = Stream(
token=stream_id9,
maxpoints=20
)
#Pitch #P
stream10 = Stream(
token=stream_id10,
maxpoints=20
)
#Heading #Q
#stream11 = Stream(
# token=stream_id11,
# maxpoints=20
#)
#Pressure #T
#stream12 = Stream(
# token=stream_id12,
# maxpoints=20
#)
#PressureAltitude #U
stream13 = Stream(
token=stream_id13,
maxpoints=20
)
#Trace names coincide with stream names
trace1 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream1
)
trace2 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream2
)
trace3 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream3
)
trace4 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream4
)
trace5 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream5
)
trace6 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream6
)
trace7 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream7
)
trace9 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream9
)
trace10 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream10
) | #trace11 = Scatter(
# x=[],
# y=[],
# mode='lines+markers',
# stream=stream11 | random_line_split |
|
cougballoon_rcv.py | (nmeaString):
#Commented out lines are for .docs, we are using .txt files instead.
#f = open('/Users/michaelhamilton/gpsbabel/nmeaRawData.doc', 'a')
f = open('/Users/michaelhamilton/gpsbabel/nmeaRawData.txt', 'a')
f.write(nmeaString)
f.close()
saveAllIncomingData(nmeaString)
#os.system("cd /Users/michaelhamilton/gpsbabel && ./gpsbabel -i nmea -f nmeaRawData.doc -o kml,deficon=http://encs.vancouver.wsu.edu/~mikehmbn/balloon-icon-map.png,line_color=FF321E98,floating=1 -F cougballoon.kml")
os.system("cd /Users/michaelhamilton/gpsbabel && ./gpsbabel -i nmea -f nmeaRawData.txt -o kml,deficon=http://encs.vancouver.wsu.edu/~mikehmbn/balloon-icon-map.png,line_color=FF321E98,floating=1 -F cougballoon.kml")
os.system("cd /Users/michaelhamilton/gpsbabel && scp cougballoon.kml [email protected]:Sites/")
print "Updated KML file was sent to the server"
return
#Get JSON data and send it to the server
def parseToJson(RMClongitude, RMClatitude, GGAaltitude, RMCspeed, RMCheading, RMCday, RMCmonth, RMCyear, RMChours, RMCminutes, RMCseconds, extTemp, intTemp, vidTemp, COlevel, CH4level, HackStatus):
JSONdata2 = { 'cougballoon':[ { 'Longitude':RMClongitude, 'Latitude':RMClatitude, 'Altitude':GGAaltitude, 'Speed':RMCspeed, 'Heading':RMCheading, 'Time':{'Day':RMCday, 'Month':RMCmonth, 'Year':RMCyear, 'Hours':RMChours, 'Minutes':RMCminutes, 'Seconds':RMCseconds},'External temperature(deg F)':extTemp, 'Internal temperature(deg F)':intTemp, 'Video Transmitter temperature(deg F)':vidTemp, 'Carbon Monoxide level(ppm)':COlevel, 'Methane level(ppm)':CH4level, 'HackHD':HackStatus } ] }
data_string2 = json.dumps(JSONdata2)
#Now post it to json_data.json for the map legend
f = open('/Users/michaelhamilton/Desktop/json_data.json', 'w')
f.write(data_string2)
f.close()
os.system("scp /Users/michaelhamilton/Desktop/json_data.json [email protected]:Sites/")
#Now to handle it for json_data.html
JSONdata = [ { 'Longitude':RMClongitude, 'Latitude':RMClatitude, 'Altitude':GGAaltitude, 'Speed(mph)':RMCspeed, 'Heading':RMCheading, 'Time':{'Day':RMCday, 'Month':RMCmonth, 'Year':RMCyear, 'Hours':RMChours, 'Minutes':RMCminutes, 'Seconds':RMCseconds},'External temperature(deg F)':extTemp, 'Internal temperature(deg F)':intTemp, 'Video Transmitter temperature(deg F)':vidTemp, 'Carbon Monoxide level(ppm)':COlevel, 'Methane level(ppm)':CH4level, 'HackHD camera statuses':HackStatus } ]
data_string = json.dumps(JSONdata)
JSONdataString = str(data_string)
newJSONdata = re.match(r'\[(.*)', JSONdataString)
newJSONdata2 = "," + newJSONdata.group(1)
f = open('/Users/michaelhamilton/Desktop/json_data.html', 'r+')
jumpBack = -1 #jump back 1 spot from the end
f.seek(jumpBack, 2) #2 is the end of the file
last = f.readline() #read the last line
while (last != "]"): #if it's not a ], then keep jumping back
jumpBack = jumpBack - 1 #decrement
if (last == "]"):
f.seek(-1, 2)
f.write(newJSONdata2)
f.close()
#Send it to the server
os.system("cd /Users/michaelhamilton/Desktop && scp json_data.html [email protected]:Sites/")
print "Updated JSON information was sent to the server."
return
#Parse out the data from an RMC nmea string
def RegExprNMEAdataRMC(line):
#if it's an RMC string....
print line
newRMCline = re.match( r'\$GPRMC,(\d\d)(\d\d)(\d\d).*,\D,(\d+.\d+),\D,(\d+.\d+),\D,(\d+.\d+),(\d+.\d+),(\d\d)(\d\d)(\d\d),.*,.*', line, re.I)
#All data are strings, not integers
if (newRMCline):
global RMChours
RMChours = newRMCline.group(1)
#Convert UTC hours to PST(Daylight Savings Time)
RMChours = UTCtoPSTDST(RMChours)
global RMCminutes
RMCminutes = newRMCline.group(2)
global RMCseconds
RMCseconds = newRMCline.group(3)
global RMClatitude
RMClatitude = newRMCline.group(4)
RMClatitude = StringToFloatGPS(RMClatitude)
global RMClongitude
RMClongitude = newRMCline.group(5)
RMClongitude = StringToFloatGPS(RMClongitude)
global RMCspeed
RMCspeed = newRMCline.group(6)
RMCspeed = StringToFloatGPS(RMCspeed)
global RMCheading
RMCheading = newRMCline.group(7)
RMCheading = StringToFloatGPS(RMCheading)
global RMCday
RMCday = newRMCline.group(8)
global RMCmonth
RMCmonth = newRMCline.group(9)
global RMCyear
RMCyear = newRMCline.group(10)
return True
else:
return False
#Parse out the data from an GGA nmea string
def RegExprNMEAdataGGA(line):
#if it's a GGA string....
print line
newGGAline = re.match( r'\$GPGGA,(\d\d)(\d\d)(\d\d).*,(.*..*),\D,(.*..*),\D,\d,\d\d\,\d.\d\d,(\d+.\d),\D.*', line, re.I)
#All data are strings, not integers
if (newGGAline):
global GGAhours
GGAhours = newGGAline.group(1)
#Convert UTC hours to PST(Daylight Savings Time)
GGAhours = UTCtoPSTDST(GGAhours)
global GGAminutes
GGAminutes = newGGAline.group(2)
global GGAseconds
GGAseconds = newGGAline.group(3)
global GGAlatitude
GGAlatitude = newGGAline.group(4)
GGAlatitude = StringToFloatGPS(GGAlatitude)
global GGAlongitude
GGAlongitude = newGGAline.group(5)
GGAlongitude = StringToFloatGPS(GGAlongitude)
global GGAaltitude
GGAaltitude = newGGAline.group(6)
GGAaltitude = StringToFloatGPS(GGAaltitude)
s2.write(dict(x=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f'), y=GGAaltitude))
return True
else:
return False
#Get my login and keys ready ro send data to plot.ly
stream_ids = tls.get_credentials_file()['stream_ids']
#Set up the plotly streams
stream_id1 = stream_ids[0]#External temperature #A
stream_id2 = stream_ids[1]#GGAaltitude #B
stream_id3 = stream_ids[2]#Internal temperature #C
#stream_id4 = stream_ids[3]#Internal pressure #D
stream_id4 = stream_ids[3]#pressureAltitude #D
#stream_id5 = stream_ids[4]#Videolynx temperature #E
stream_id5 = stream_ids[4]#10DOF temperature #E
stream_id6 = stream_ids[5]#CO level in ppm #F
stream_id7 = stream_ids[6]#CH4 level in ppm #G
stream_id8 = stream_ids[7]#Humidity #J
stream_id9 = stream_ids[8]#Roll #L
stream_id10 = stream_ids[9]#Pitch #P
#stream_id11 = stream_ids | handleGPSdata | identifier_name |
|
cougballoon_rcv.py |
#Save all incoming data with a current date/time string
def saveData(a):
x = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
saveAllIncomingData(x)
saveAllIncomingData(a)
#Convert GPS strings to floats (Couldn't get str.isnumeric() to work correctly)
def StringToFloatGPS(a):
a = a.rstrip('\n');
a = a.rstrip('\r');
a = float(a)
return a
#FIX SO IT DOES NOT RETURN A ZERO!!!!!!!!
#COnvert data strings to floats
def StringToFloat(a, b):
#print len(a)
if (len(a) < 4):
print "Incomplete data, returning a zero."
return b
a = a[1:len(a)]
a = a.rstrip('\n');
a = a.rstrip('\r');
if (a == "-"):
print "Only a negative sign in string, returning a zero."
return b
a = float(a)
return a
#Saves all incoming data to a file on the desktop
def saveAllIncomingData(c):
f = open('/Users/michaelhamilton/Desktop/cougballoonData.txt', 'a')
f.write(c)
f.close
#Convert nmea string to .kml file, send to server
def handleGPSdata(nmeaString):
#Commented out lines are for .docs, we are using .txt files instead.
#f = open('/Users/michaelhamilton/gpsbabel/nmeaRawData.doc', 'a')
f = open('/Users/michaelhamilton/gpsbabel/nmeaRawData.txt', 'a')
f.write(nmeaString)
f.close()
saveAllIncomingData(nmeaString)
#os.system("cd /Users/michaelhamilton/gpsbabel && ./gpsbabel -i nmea -f nmeaRawData.doc -o kml,deficon=http://encs.vancouver.wsu.edu/~mikehmbn/balloon-icon-map.png,line_color=FF321E98,floating=1 -F cougballoon.kml")
os.system("cd /Users/michaelhamilton/gpsbabel && ./gpsbabel -i nmea -f nmeaRawData.txt -o kml,deficon=http://encs.vancouver.wsu.edu/~mikehmbn/balloon-icon-map.png,line_color=FF321E98,floating=1 -F cougballoon.kml")
os.system("cd /Users/michaelhamilton/gpsbabel && scp cougballoon.kml [email protected]:Sites/")
print "Updated KML file was sent to the server"
return
#Get JSON data and send it to the server
def parseToJson(RMClongitude, RMClatitude, GGAaltitude, RMCspeed, RMCheading, RMCday, RMCmonth, RMCyear, RMChours, RMCminutes, RMCseconds, extTemp, intTemp, vidTemp, COlevel, CH4level, HackStatus):
JSONdata2 = { 'cougballoon':[ { 'Longitude':RMClongitude, 'Latitude':RMClatitude, 'Altitude':GGAaltitude, 'Speed':RMCspeed, 'Heading':RMCheading, 'Time':{'Day':RMCday, 'Month':RMCmonth, 'Year':RMCyear, 'Hours':RMChours, 'Minutes':RMCminutes, 'Seconds':RMCseconds},'External temperature(deg F)':extTemp, 'Internal temperature(deg F)':intTemp, 'Video Transmitter temperature(deg F)':vidTemp, 'Carbon Monoxide level(ppm)':COlevel, 'Methane level(ppm)':CH4level, 'HackHD':HackStatus } ] }
data_string2 = json.dumps(JSONdata2)
#Now post it to json_data.json for the map legend
f = open('/Users/michaelhamilton/Desktop/json_data.json', 'w')
f.write(data_string2)
f.close()
os.system("scp /Users/michaelhamilton/Desktop/json_data.json [email protected]:Sites/")
#Now to handle it for json_data.html
JSONdata = [ { 'Longitude':RMClongitude, 'Latitude':RMClatitude, 'Altitude':GGAaltitude, 'Speed(mph)':RMCspeed, 'Heading':RMCheading, 'Time':{'Day':RMCday, 'Month':RMCmonth, 'Year':RMCyear, 'Hours':RMChours, 'Minutes':RMCminutes, 'Seconds':RMCseconds},'External temperature(deg F)':extTemp, 'Internal temperature(deg F)':intTemp, 'Video Transmitter temperature(deg F)':vidTemp, 'Carbon Monoxide level(ppm)':COlevel, 'Methane level(ppm)':CH4level, 'HackHD camera statuses':HackStatus } ]
data_string = json.dumps(JSONdata)
JSONdataString = str(data_string)
newJSONdata = re.match(r'\[(.*)', JSONdataString)
newJSONdata2 = "," + newJSONdata.group(1)
f = open('/Users/michaelhamilton/Desktop/json_data.html', 'r+')
jumpBack = -1 #jump back 1 spot from the end
f.seek(jumpBack, 2) #2 is the end of the file
last = f.readline() #read the last line
while (last != "]"): #if it's not a ], then keep jumping back
jumpBack = jumpBack - 1 #decrement
if (last == "]"):
f.seek(-1, 2)
f.write(newJSONdata2)
f.close()
#Send it to the server
os.system("cd /Users/michaelhamilton/Desktop && scp json_data.html [email protected]:Sites/")
print "Updated JSON information was sent to the server."
return
#Parse out the data from an RMC nmea string
def RegExprNMEAdataRMC(line):
#if it's an RMC string....
print line
newRMCline = re.match( r'\$GPRMC,(\d\d)(\d\d)(\d\d).*,\D,(\d+.\d+),\D,(\d+.\d+),\D,(\d+.\d+),(\d+.\d+),(\d\d)(\d\d)(\d\d),.*,.*', line, re.I)
#All data are strings, not integers
if (newRMCline):
global RMChours
RMChours = newRMCline.group(1)
#Convert UTC hours to PST(Daylight Savings Time)
RMChours = UTCtoPSTDST(RMChours)
global RMCminutes
RMCminutes = newRMCline.group(2)
global RMCseconds
RMCseconds = newRMCline.group(3)
global RMClatitude
RMClatitude = newRMCline.group(4)
RMClatitude = StringToFloatGPS(RMClatitude)
global RMClongitude
RMClongitude = newRMCline.group(5)
RMClongitude = StringToFloatGPS(RMClongitude)
global RMCspeed
RMCspeed = newRMCline.group(6)
RMCspeed = StringToFloatGPS(RMCspeed)
global RMCheading
RMCheading = newRMCline.group(7)
RMCheading = StringToFloatGPS(RMCheading)
global RMCday
RMCday = newRMCline.group(8)
global RMCmonth
RMCmonth = newRMCline.group(9)
global RMCyear
RMCyear = newRMCline.group(10)
return True
else:
return False
#Parse out the data from an GGA nmea string
def RegExprNMEAdataGGA(line):
#if it's a GGA string....
print line
newGGAline = re.match( r'\$GPGGA,(\d\d)(\d\d)(\d\d).*,(.*..*),\D,(.*..*),\D,\d,\d\d\,\d.\d\d,(\d+.\d),\D.*', line, re.I)
#All data are strings, not integers
if (newGGAline):
global GGAhours
GGAhours = newGGAline.group(1)
#Convert UTC hours to PST(Daylight Savings Time)
GGAhours = UTCtoPSTDST(GGAhours)
global GGAminutes
GGAminutes = newGGAline.group(2)
global GGAseconds
GGAseconds = newGGAline.group(3)
global GGAlatitude
GGAlatitude = newGGAline.group(4)
GGAlatitude = StringToFloatGPS(GGAlatitude)
global GGAlongitude
| hours = hours.rstrip('\n');
hours = hours.rstrip('\r');
hours = int(hours) + 17
if (hours > 24):
hours = hours - 24
hours = str(hours)
return hours | identifier_body |
|
cougballoon_rcv.py | mode='lines+markers',
stream=stream2
)
trace3 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream3
)
trace4 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream4
)
trace5 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream5
)
trace6 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream6
)
trace7 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream7
)
trace9 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream9
)
trace10 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream10
)
#trace11 = Scatter(
# x=[],
# y=[],
# mode='lines+markers',
# stream=stream11
#)
#trace12 = Scatter(
# x=[],
# y=[],
# mode='lines+markers',
# stream=stream12
#)
trace13 = Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream13
)
#Set up the plotly graphs
data_graph_a = Data([trace1, trace3, trace5])
data_graph_b = Data([trace6, trace7])
data_graph_c = Data([trace9, trace10])
#data_graph_d = Data([trace2, trace4])#Does not work
data_graph_e = Data([trace2, trace4])
layout_a = Layout(title='#cougballoon temperatures')#This is the name on the graph
layout_b = Layout(title='#cougballoon air quality levels')#This is the name on the graph
layout_c = Layout(title='#cougballoon payload pitch and roll data')#This is the name on the graph
#layout_d = Layout(title='#cougballoon altitude')#This is the name on the graph
layout_e = Layout(title='#cougballoon altitude')#This is the name on the graph
fig_a = Figure(data=data_graph_a, layout=layout_a)
fig_b = Figure(data=data_graph_b, layout=layout_b)
fig_c = Figure(data=data_graph_c, layout=layout_c)
#fig_d = Figure(data=data_graph_d, layout=layout_d)
fig_e = Figure(data=data_graph_e, layout=layout_e)
unique_url_a = py.plot(fig_a, filename='cougballoon1', fileopt='extend')#Name above the graph
unique_url_b = py.plot(fig_b, filename='cougballoon2', fileopt='extend')#Name above the graph
unique_url_c = py.plot(fig_c, filename='cougballoon3', fileopt='extend')#Name above the graph
#unique_url_d = py.plot(fig_d, filename='cougballoon4', fileopt='extend')#Name above the graph
unique_url_e = py.plot(fig_e, filename='cougballoon5', fileopt='extend')#Name above the graph
#Print the plotly urls
print unique_url_a
print unique_url_b
print unique_url_c
#print unique_url_d
print unique_url_e
#Get the plotly streams ready
s1 = py.Stream(stream_id1)
s2 = py.Stream(stream_id2)
s3 = py.Stream(stream_id3)
s4 = py.Stream(stream_id4)
s5 = py.Stream(stream_id5)
s6 = py.Stream(stream_id6)
s7 = py.Stream(stream_id7)
s9 = py.Stream(stream_id9)
s10 = py.Stream(stream_id10)
#s11 = py.Stream(stream_id11)
#s12 = py.Stream(stream_id12)
#s13 = py.Stream(stream_id13)
#Open the plotly streams
s1.open()
s2.open()
s3.open()
s4.open()
s5.open()
s6.open()
s7.open()
s9.open()
s10.open()
#s11.open()
#s12.open()
#s13.open()
import datetime
import time
# Delay start of stream by 5 sec (time to switch tabs)
time.sleep(5)
#Clean out the buffers
line = ser.readline()
time.sleep(2)
line = ser.readline()
time.sleep(2)
line = ser.readline()
time.sleep(2)
while True:
# Current time on x-axis, values on y-axis
x = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
line = ser.readline() #properly captures incoming string
#External temperature #A
if ((line.find("A")) == 0):
print "External temperature:"
print line
y = StringToFloat(line, extTemp)
saveData(line)
extTemp = y
print y
s1.write(dict(x=x, y=y))
#External pressure #B
elif ((line.find("B")) == 0):
print "External Pressure:"
print line
y = StringToFloat(line)
saveData(line)
print y
#s2.write(dict(x=x, y=y))
#Internal temperature #C
elif ((line.find("C")) == 0):
print "Internal temperature:"
print line
y = StringToFloat(line, intTemp)
saveData(line)
intTemp = y
print y
s3.write(dict(x=x, y=y))
#Internal pressure #D
#elif ((line.find("D")) == 0):
#print "Internal pressure:"
#print line
#y = StringToFloat(line)
#saveData(line)
#print y
#s4.write(dict(x=x, y=y))
#Videolynx temperature #E
elif ((line.find("E")) == 0):
print "Videolynx temperature:"
print line
y = StringToFloat(line)
saveData(line)
vidTemp = y
print y
#s5.write(dict(x=x, y=y))
#CO level in ppm #F
elif ((line.find("F")) == 0):
print "CO level (in ppm):"
print line
y = StringToFloat(line, COlevel)
saveData(line)
COlevel = y
print y
s6.write(dict(x=x, y=y))
#CH4 level in ppm #G
elif ((line.find("G")) == 0):
print "CH4 level (in ppm):"
print line
y = StringToFloat(line, CH4level)
saveData(line)
CH4level = y
print y
s7.write(dict(x=x, y=y))
#Humidity #J
elif ((line.find("J")) == 0):
print "Humidity:"
print line
y = StringToFloat(line)
saveData(line)
print y
#What data do we want here?
elif ((line.find("K")) == 0):
print "FOUND A K!"
print line
y = StringToFloat(line)
saveData(line)
print y
#What data do we want here?
elif ((line.find("L")) == 0):
print "Roll:"
print line
y = StringToFloat(line, roll)
saveData(line)
roll = y
print y
s9.write(dict(x=x, y=y))
#HACKHD INFO BELOW
elif ((line.find("Hack")) == 0):
print "HackHD information"
print line
saveData(line)
HackStatus = line
HackStatus = HackStatus[6:13]
HackStatus = HackStatus.rstrip('\n');
HackStatus = HackStatus.rstrip('\r');
print HackStatus
#What data do we want here?
elif ((line.find("P")) == 0):
print "Pitch:"
print line
y = StringToFloat(line, pitch)
saveData(line)
pitch = y
print y
s10.write(dict(x=x, y=y))
#What data do we want here?
elif ((line.find("Q")) == 0):
print "Heading:"
print line
y = StringToFloat(line, heading)
saveData(line)
heading = y
print y
#s11.write(dict(x=x, y=y))
#What data do we want here?
elif ((line.find("T")) == 0):
print "Pressure"
print line
y = StringToFloat(line, pressure)
saveData(line)
pressure = y
print y
#What data do we want here?
elif ((line.find("U")) == 0):
| print "Altitude(from press/temp):"
print line
y = StringToFloat(line, pressureAltitude)
saveData(line)
pressureAltitude = y
print y
s4.write(dict(x=x, y=y)) | conditional_block |
|
options.go | option()
}
// Options is a list of Option values that also satisfies the Option interface.
// Helper comparison packages may return an Options value when packing multiple
// Option values into a single Option. When this package processes an Options,
// it will be implicitly expanded into a flat list.
//
// Applying a filter on an Options is equivalent to applying that same filter
// on all individual options held within.
type Options []Option
func (Options) option() {}
type (
pathFilter func(Path) bool
valueFilter struct {
in reflect.Type // T
fnc reflect.Value // func(T, T) bool
}
)
type option struct {
typeFilter reflect.Type
pathFilters []pathFilter
valueFilters []valueFilter
// op is the operation to perform. If nil, then this acts as an ignore.
op interface{} // nil | *transformer | *comparer
}
func (option) | () {}
func (o option) String() string {
// TODO: Add information about the caller?
// TODO: Maintain the order that filters were added?
var ss []string
switch op := o.op.(type) {
case *transformer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Transformer(%s, %s)", op.name, fn))
case *comparer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Comparer(%s)", fn))
default:
ss = append(ss, "Ignore()")
}
for _, f := range o.pathFilters {
fn := getFuncName(reflect.ValueOf(f).Pointer())
ss = append(ss, fmt.Sprintf("FilterPath(%s)", fn))
}
for _, f := range o.valueFilters {
fn := getFuncName(f.fnc.Pointer())
ss = append(ss, fmt.Sprintf("FilterValues(%s)", fn))
}
return strings.Join(ss, "\n\t")
}
// getFuncName returns a short function name from the pointer.
// The string parsing logic works up until Go1.9.
func getFuncName(p uintptr) string {
fnc := runtime.FuncForPC(p)
if fnc == nil {
return "<unknown>"
}
name := fnc.Name() // E.g., "long/path/name/mypkg.(mytype).(long/path/name/mypkg.myfunc)-fm"
if strings.HasSuffix(name, ")-fm") || strings.HasSuffix(name, ")·fm") {
// Strip the package name from method name.
name = strings.TrimSuffix(name, ")-fm")
name = strings.TrimSuffix(name, ")·fm")
if i := strings.LastIndexByte(name, '('); i >= 0 {
methodName := name[i+1:] // E.g., "long/path/name/mypkg.myfunc"
if j := strings.LastIndexByte(methodName, '.'); j >= 0 {
methodName = methodName[j+1:] // E.g., "myfunc"
}
name = name[:i] + methodName // E.g., "long/path/name/mypkg.(mytype)." + "myfunc"
}
}
if i := strings.LastIndexByte(name, '/'); i >= 0 {
// Strip the package name.
name = name[i+1:] // E.g., "mypkg.(mytype).myfunc"
}
return name
}
// FilterPath returns a new Option where opt is only evaluated if filter f
// returns true for the current Path in the value tree.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterPath(f func(Path) bool, opt Option) Option {
if f == nil {
panic("invalid path filter function")
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterPath(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.pathFilters)
opt.pathFilters = append(opt.pathFilters[:n:n], f) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// FilterValues returns a new Option where opt is only evaluated if filter f,
// which is a function of the form "func(T, T) bool", returns true for the
// current pair of values being compared. If the type of the values is not
// assignable to T, then this filter implicitly returns false.
//
// The filter function must be
// symmetric (i.e., agnostic to the order of the inputs) and
// deterministic (i.e., produces the same result when given the same inputs).
// If T is an interface, it is possible that f is called with two values with
// different concrete types that both implement T.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterValues(f interface{}, opt Option) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != valueFilterFunc || v.IsNil() {
panic(fmt.Sprintf("invalid values filter function: %T", f))
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterValues(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.valueFilters)
vf := valueFilter{v.Type().In(0), v}
opt.valueFilters = append(opt.valueFilters[:n:n], vf) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// Ignore is an Option that causes all comparisons to be ignored.
// This value is intended to be combined with FilterPath or FilterValues.
// It is an error to pass an unfiltered Ignore option to Equal.
func Ignore() Option {
return option{}
}
// Transformer returns an Option that applies a transformation function that
// converts values of a certain type into that of another.
//
// The transformer f must be a function "func(T) R" that converts values of
// type T to those of type R and is implicitly filtered to input values
// assignable to T. The transformer must not mutate T in any way.
// If T and R are the same type, an additional filter must be applied to
// act as the base case to prevent an infinite recursion applying the same
// transform to itself (see the SortedSlice example).
//
// The name is a user provided label that is used as the Transform.Name in the
// transformation PathStep. If empty, an arbitrary name is used.
func Transformer(name string, f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != transformFunc || v.IsNil() {
panic(fmt.Sprintf("invalid transformer function: %T", f))
}
if name == "" {
name = "λ" // Lambda-symbol as place-holder for anonymous transformer
}
if !isValid(name) {
panic(fmt.Sprintf("invalid name: %q", name))
}
opt := option{op: &transformer{name, reflect.ValueOf(f)}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type transformer struct {
name string
fnc reflect.Value // func(T) R
}
// Comparer returns an Option that determines whether two values are equal
// to each other.
//
// The comparer f must be a function "func(T, T) bool" and is implicitly
// filtered to input values assignable to T. If T is an interface, it is
// possible that f is called with two values of different concrete types that
// both implement T.
//
// The equality function must be:
// • Symmetric: equal(x, y) == equal(y, x)
// • Deterministic: equal(x, y) == equal(x, y)
// • Pure: equal(x, y) does not modify x or y
func Comparer(f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != equalFunc || v.IsNil() {
panic(fmt.Sprintf("invalid comparer function: %T", f))
}
opt := option{op: &comparer{v}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type comparer struct {
fnc reflect.Value // func(T, T) bool
}
// AllowUnexported returns an Option that forcibly allows operations on
// unexported fields in certain structs, which are specified by passing in a
// value of each struct type.
//
// Users of this option must understand that comparing on unexported fields
// from external packages is not safe since changes in the internal
// implementation of some external package may cause the result of Equal
// to unexpectedly change. However, it may be valid to use this option on types
// defined in an internal package where the semantic meaning of an unexported
// field is in the control of the user.
//
// For some cases, a custom Comparer should be used instead that defines
// equality as a function of the public API of a type rather than the underlying
// unexported implementation.
//
// For example, the reflect.Type documentation defines equality to be determined
// by the == operator on the | option | identifier_name |
options.go | option()
}
// Options is a list of Option values that also satisfies the Option interface.
// Helper comparison packages may return an Options value when packing multiple
// Option values into a single Option. When this package processes an Options,
// it will be implicitly expanded into a flat list.
//
// Applying a filter on an Options is equivalent to applying that same filter
// on all individual options held within.
type Options []Option
func (Options) option() {}
type (
pathFilter func(Path) bool
valueFilter struct {
in reflect.Type // T
fnc reflect.Value // func(T, T) bool
}
)
type option struct {
typeFilter reflect.Type
pathFilters []pathFilter
valueFilters []valueFilter
// op is the operation to perform. If nil, then this acts as an ignore.
op interface{} // nil | *transformer | *comparer
}
func (option) option() {}
func (o option) String() string {
// TODO: Add information about the caller?
// TODO: Maintain the order that filters were added?
var ss []string
switch op := o.op.(type) {
case *transformer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Transformer(%s, %s)", op.name, fn))
case *comparer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Comparer(%s)", fn))
default:
ss = append(ss, "Ignore()")
}
for _, f := range o.pathFilters {
fn := getFuncName(reflect.ValueOf(f).Pointer())
ss = append(ss, fmt.Sprintf("FilterPath(%s)", fn))
}
for _, f := range o.valueFilters {
fn := getFuncName(f.fnc.Pointer())
ss = append(ss, fmt.Sprintf("FilterValues(%s)", fn))
}
return strings.Join(ss, "\n\t")
}
// getFuncName returns a short function name from the pointer.
// The string parsing logic works up until Go1.9.
func getFuncName(p uintptr) string | name = name[i+1:] // E.g., "mypkg.(mytype).myfunc"
}
return name
}
// FilterPath returns a new Option where opt is only evaluated if filter f
// returns true for the current Path in the value tree.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterPath(f func(Path) bool, opt Option) Option {
if f == nil {
panic("invalid path filter function")
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterPath(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.pathFilters)
opt.pathFilters = append(opt.pathFilters[:n:n], f) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// FilterValues returns a new Option where opt is only evaluated if filter f,
// which is a function of the form "func(T, T) bool", returns true for the
// current pair of values being compared. If the type of the values is not
// assignable to T, then this filter implicitly returns false.
//
// The filter function must be
// symmetric (i.e., agnostic to the order of the inputs) and
// deterministic (i.e., produces the same result when given the same inputs).
// If T is an interface, it is possible that f is called with two values with
// different concrete types that both implement T.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterValues(f interface{}, opt Option) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != valueFilterFunc || v.IsNil() {
panic(fmt.Sprintf("invalid values filter function: %T", f))
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterValues(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.valueFilters)
vf := valueFilter{v.Type().In(0), v}
opt.valueFilters = append(opt.valueFilters[:n:n], vf) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// Ignore is an Option that causes all comparisons to be ignored.
// This value is intended to be combined with FilterPath or FilterValues.
// It is an error to pass an unfiltered Ignore option to Equal.
func Ignore() Option {
return option{}
}
// Transformer returns an Option that applies a transformation function that
// converts values of a certain type into that of another.
//
// The transformer f must be a function "func(T) R" that converts values of
// type T to those of type R and is implicitly filtered to input values
// assignable to T. The transformer must not mutate T in any way.
// If T and R are the same type, an additional filter must be applied to
// act as the base case to prevent an infinite recursion applying the same
// transform to itself (see the SortedSlice example).
//
// The name is a user provided label that is used as the Transform.Name in the
// transformation PathStep. If empty, an arbitrary name is used.
func Transformer(name string, f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != transformFunc || v.IsNil() {
panic(fmt.Sprintf("invalid transformer function: %T", f))
}
if name == "" {
name = "λ" // Lambda-symbol as place-holder for anonymous transformer
}
if !isValid(name) {
panic(fmt.Sprintf("invalid name: %q", name))
}
opt := option{op: &transformer{name, reflect.ValueOf(f)}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type transformer struct {
name string
fnc reflect.Value // func(T) R
}
// Comparer returns an Option that determines whether two values are equal
// to each other.
//
// The comparer f must be a function "func(T, T) bool" and is implicitly
// filtered to input values assignable to T. If T is an interface, it is
// possible that f is called with two values of different concrete types that
// both implement T.
//
// The equality function must be:
// • Symmetric: equal(x, y) == equal(y, x)
// • Deterministic: equal(x, y) == equal(x, y)
// • Pure: equal(x, y) does not modify x or y
func Comparer(f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != equalFunc || v.IsNil() {
panic(fmt.Sprintf("invalid comparer function: %T", f))
}
opt := option{op: &comparer{v}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type comparer struct {
fnc reflect.Value // func(T, T) bool
}
// AllowUnexported returns an Option that forcibly allows operations on
// unexported fields in certain structs, which are specified by passing in a
// value of each struct type.
//
// Users of this option must understand that comparing on unexported fields
// from external packages is not safe since changes in the internal
// implementation of some external package may cause the result of Equal
// to unexpectedly change. However, it may be valid to use this option on types
// defined in an internal package where the semantic meaning of an unexported
// field is in the control of the user.
//
// For some cases, a custom Comparer should be used instead that defines
// equality as a function of the public API of a type rather than the underlying
// unexported implementation.
//
// For example, the reflect.Type documentation defines equality to be determined
// by the == operator on the | {
fnc := runtime.FuncForPC(p)
if fnc == nil {
return "<unknown>"
}
name := fnc.Name() // E.g., "long/path/name/mypkg.(mytype).(long/path/name/mypkg.myfunc)-fm"
if strings.HasSuffix(name, ")-fm") || strings.HasSuffix(name, ")·fm") {
// Strip the package name from method name.
name = strings.TrimSuffix(name, ")-fm")
name = strings.TrimSuffix(name, ")·fm")
if i := strings.LastIndexByte(name, '('); i >= 0 {
methodName := name[i+1:] // E.g., "long/path/name/mypkg.myfunc"
if j := strings.LastIndexByte(methodName, '.'); j >= 0 {
methodName = methodName[j+1:] // E.g., "myfunc"
}
name = name[:i] + methodName // E.g., "long/path/name/mypkg.(mytype)." + "myfunc"
}
}
if i := strings.LastIndexByte(name, '/'); i >= 0 {
// Strip the package name. | identifier_body |
options.go | "runtime"
"strings"
)
// Option configures for specific behavior of Equal and Diff. In particular,
// the fundamental Option functions (Ignore, Transformer, and Comparer),
// configure how equality is determined.
//
// The fundamental options may be composed with filters (FilterPath and
// FilterValues) to control the scope over which they are applied.
//
// The cmp/cmpopts package provides helper functions for creating options that
// may be used with Equal and Diff.
type Option interface {
// Prevent Option from being equivalent to interface{}, which provides
// a small type checking benefit by preventing Equal(opt, x, y).
option()
}
// Options is a list of Option values that also satisfies the Option interface.
// Helper comparison packages may return an Options value when packing multiple
// Option values into a single Option. When this package processes an Options,
// it will be implicitly expanded into a flat list.
//
// Applying a filter on an Options is equivalent to applying that same filter
// on all individual options held within.
type Options []Option
func (Options) option() {}
type (
pathFilter func(Path) bool
valueFilter struct {
in reflect.Type // T
fnc reflect.Value // func(T, T) bool
}
)
type option struct {
typeFilter reflect.Type
pathFilters []pathFilter
valueFilters []valueFilter
// op is the operation to perform. If nil, then this acts as an ignore.
op interface{} // nil | *transformer | *comparer
}
func (option) option() {}
func (o option) String() string {
// TODO: Add information about the caller?
// TODO: Maintain the order that filters were added?
var ss []string
switch op := o.op.(type) {
case *transformer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Transformer(%s, %s)", op.name, fn))
case *comparer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Comparer(%s)", fn))
default:
ss = append(ss, "Ignore()")
}
for _, f := range o.pathFilters {
fn := getFuncName(reflect.ValueOf(f).Pointer())
ss = append(ss, fmt.Sprintf("FilterPath(%s)", fn))
}
for _, f := range o.valueFilters {
fn := getFuncName(f.fnc.Pointer())
ss = append(ss, fmt.Sprintf("FilterValues(%s)", fn))
}
return strings.Join(ss, "\n\t")
}
// getFuncName returns a short function name from the pointer.
// The string parsing logic works up until Go1.9.
func getFuncName(p uintptr) string {
fnc := runtime.FuncForPC(p)
if fnc == nil {
return "<unknown>"
}
name := fnc.Name() // E.g., "long/path/name/mypkg.(mytype).(long/path/name/mypkg.myfunc)-fm"
if strings.HasSuffix(name, ")-fm") || strings.HasSuffix(name, ")·fm") {
// Strip the package name from method name.
name = strings.TrimSuffix(name, ")-fm")
name = strings.TrimSuffix(name, ")·fm")
if i := strings.LastIndexByte(name, '('); i >= 0 {
methodName := name[i+1:] // E.g., "long/path/name/mypkg.myfunc"
if j := strings.LastIndexByte(methodName, '.'); j >= 0 {
methodName = methodName[j+1:] // E.g., "myfunc"
}
name = name[:i] + methodName // E.g., "long/path/name/mypkg.(mytype)." + "myfunc"
}
}
if i := strings.LastIndexByte(name, '/'); i >= 0 {
// Strip the package name.
name = name[i+1:] // E.g., "mypkg.(mytype).myfunc"
}
return name
}
// FilterPath returns a new Option where opt is only evaluated if filter f
// returns true for the current Path in the value tree.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterPath(f func(Path) bool, opt Option) Option {
if f == nil {
panic("invalid path filter function")
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterPath(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.pathFilters)
opt.pathFilters = append(opt.pathFilters[:n:n], f) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// FilterValues returns a new Option where opt is only evaluated if filter f,
// which is a function of the form "func(T, T) bool", returns true for the
// current pair of values being compared. If the type of the values is not
// assignable to T, then this filter implicitly returns false.
//
// The filter function must be
// symmetric (i.e., agnostic to the order of the inputs) and
// deterministic (i.e., produces the same result when given the same inputs).
// If T is an interface, it is possible that f is called with two values with
// different concrete types that both implement T.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterValues(f interface{}, opt Option) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != valueFilterFunc || v.IsNil() {
panic(fmt.Sprintf("invalid values filter function: %T", f))
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterValues(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.valueFilters)
vf := valueFilter{v.Type().In(0), v}
opt.valueFilters = append(opt.valueFilters[:n:n], vf) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// Ignore is an Option that causes all comparisons to be ignored.
// This value is intended to be combined with FilterPath or FilterValues.
// It is an error to pass an unfiltered Ignore option to Equal.
func Ignore() Option {
return option{}
}
// Transformer returns an Option that applies a transformation function that
// converts values of a certain type into that of another.
//
// The transformer f must be a function "func(T) R" that converts values of
// type T to those of type R and is implicitly filtered to input values
// assignable to T. The transformer must not mutate T in any way.
// If T and R are the same type, an additional filter must be applied to
// act as the base case to prevent an infinite recursion applying the same
// transform to itself (see the SortedSlice example).
//
// The name is a user provided label that is used as the Transform.Name in the
// transformation PathStep. If empty, an arbitrary name is used.
func Transformer(name string, f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != transformFunc || v.IsNil() {
panic(fmt.Sprintf("invalid transformer function: %T", f))
}
if name == "" {
name = "λ" // Lambda-symbol as place-holder for anonymous transformer
}
if !isValid(name) {
panic(fmt.Sprintf("invalid name: %q", name))
}
opt := option{op: &transformer{name, reflect.ValueOf(f)}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type transformer struct {
name string
fnc reflect.Value // func(T) R
}
// Comparer returns an Option that determines whether two values are equal
// to each other.
//
// The comparer f must be a function "func(T, T) bool" and is implicitly
// filtered to input values assignable to T. If T is an interface, it is
// possible that f is called with two values of different concrete types that
// both implement T.
//
// The equality function must be:
// • Symmetric: equal(x, y) == equal(y, x)
// • Deterministic: equal(x, y) == equal(x, y)
// • Pure: equal(x, y) does not modify x or y
func Comparer(f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != equalFunc || v.IsNil() {
panic(fmt.Sprintf("invalid comparer function: %T", f))
}
opt := option{op: &comparer{v}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type comparer struct {
fnc reflect.Value // func(T, T) bool
}
// AllowUnexported returns an Option that forcibly allows operations on
// unexported fields in certain structs, which are specified by passing in a
// value of each struct type.
//
// Users of this option must understand that | import (
"fmt"
"reflect" | random_line_split |
|
options.go | option()
}
// Options is a list of Option values that also satisfies the Option interface.
// Helper comparison packages may return an Options value when packing multiple
// Option values into a single Option. When this package processes an Options,
// it will be implicitly expanded into a flat list.
//
// Applying a filter on an Options is equivalent to applying that same filter
// on all individual options held within.
type Options []Option
func (Options) option() {}
type (
pathFilter func(Path) bool
valueFilter struct {
in reflect.Type // T
fnc reflect.Value // func(T, T) bool
}
)
type option struct {
typeFilter reflect.Type
pathFilters []pathFilter
valueFilters []valueFilter
// op is the operation to perform. If nil, then this acts as an ignore.
op interface{} // nil | *transformer | *comparer
}
func (option) option() {}
func (o option) String() string {
// TODO: Add information about the caller?
// TODO: Maintain the order that filters were added?
var ss []string
switch op := o.op.(type) {
case *transformer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Transformer(%s, %s)", op.name, fn))
case *comparer:
fn := getFuncName(op.fnc.Pointer())
ss = append(ss, fmt.Sprintf("Comparer(%s)", fn))
default:
ss = append(ss, "Ignore()")
}
for _, f := range o.pathFilters {
fn := getFuncName(reflect.ValueOf(f).Pointer())
ss = append(ss, fmt.Sprintf("FilterPath(%s)", fn))
}
for _, f := range o.valueFilters {
fn := getFuncName(f.fnc.Pointer())
ss = append(ss, fmt.Sprintf("FilterValues(%s)", fn))
}
return strings.Join(ss, "\n\t")
}
// getFuncName returns a short function name from the pointer.
// The string parsing logic works up until Go1.9.
func getFuncName(p uintptr) string {
fnc := runtime.FuncForPC(p)
if fnc == nil |
name := fnc.Name() // E.g., "long/path/name/mypkg.(mytype).(long/path/name/mypkg.myfunc)-fm"
if strings.HasSuffix(name, ")-fm") || strings.HasSuffix(name, ")·fm") {
// Strip the package name from method name.
name = strings.TrimSuffix(name, ")-fm")
name = strings.TrimSuffix(name, ")·fm")
if i := strings.LastIndexByte(name, '('); i >= 0 {
methodName := name[i+1:] // E.g., "long/path/name/mypkg.myfunc"
if j := strings.LastIndexByte(methodName, '.'); j >= 0 {
methodName = methodName[j+1:] // E.g., "myfunc"
}
name = name[:i] + methodName // E.g., "long/path/name/mypkg.(mytype)." + "myfunc"
}
}
if i := strings.LastIndexByte(name, '/'); i >= 0 {
// Strip the package name.
name = name[i+1:] // E.g., "mypkg.(mytype).myfunc"
}
return name
}
// FilterPath returns a new Option where opt is only evaluated if filter f
// returns true for the current Path in the value tree.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterPath(f func(Path) bool, opt Option) Option {
if f == nil {
panic("invalid path filter function")
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterPath(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.pathFilters)
opt.pathFilters = append(opt.pathFilters[:n:n], f) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// FilterValues returns a new Option where opt is only evaluated if filter f,
// which is a function of the form "func(T, T) bool", returns true for the
// current pair of values being compared. If the type of the values is not
// assignable to T, then this filter implicitly returns false.
//
// The filter function must be
// symmetric (i.e., agnostic to the order of the inputs) and
// deterministic (i.e., produces the same result when given the same inputs).
// If T is an interface, it is possible that f is called with two values with
// different concrete types that both implement T.
//
// The option passed in may be an Ignore, Transformer, Comparer, Options, or
// a previously filtered Option.
func FilterValues(f interface{}, opt Option) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != valueFilterFunc || v.IsNil() {
panic(fmt.Sprintf("invalid values filter function: %T", f))
}
switch opt := opt.(type) {
case Options:
var opts []Option
for _, o := range opt {
opts = append(opts, FilterValues(f, o)) // Append to slice copy
}
return Options(opts)
case option:
n := len(opt.valueFilters)
vf := valueFilter{v.Type().In(0), v}
opt.valueFilters = append(opt.valueFilters[:n:n], vf) // Append to copy
return opt
default:
panic(fmt.Sprintf("unknown option type: %T", opt))
}
}
// Ignore is an Option that causes all comparisons to be ignored.
// This value is intended to be combined with FilterPath or FilterValues.
// It is an error to pass an unfiltered Ignore option to Equal.
func Ignore() Option {
return option{}
}
// Transformer returns an Option that applies a transformation function that
// converts values of a certain type into that of another.
//
// The transformer f must be a function "func(T) R" that converts values of
// type T to those of type R and is implicitly filtered to input values
// assignable to T. The transformer must not mutate T in any way.
// If T and R are the same type, an additional filter must be applied to
// act as the base case to prevent an infinite recursion applying the same
// transform to itself (see the SortedSlice example).
//
// The name is a user provided label that is used as the Transform.Name in the
// transformation PathStep. If empty, an arbitrary name is used.
func Transformer(name string, f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != transformFunc || v.IsNil() {
panic(fmt.Sprintf("invalid transformer function: %T", f))
}
if name == "" {
name = "λ" // Lambda-symbol as place-holder for anonymous transformer
}
if !isValid(name) {
panic(fmt.Sprintf("invalid name: %q", name))
}
opt := option{op: &transformer{name, reflect.ValueOf(f)}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type transformer struct {
name string
fnc reflect.Value // func(T) R
}
// Comparer returns an Option that determines whether two values are equal
// to each other.
//
// The comparer f must be a function "func(T, T) bool" and is implicitly
// filtered to input values assignable to T. If T is an interface, it is
// possible that f is called with two values of different concrete types that
// both implement T.
//
// The equality function must be:
// • Symmetric: equal(x, y) == equal(y, x)
// • Deterministic: equal(x, y) == equal(x, y)
// • Pure: equal(x, y) does not modify x or y
func Comparer(f interface{}) Option {
v := reflect.ValueOf(f)
if functionType(v.Type()) != equalFunc || v.IsNil() {
panic(fmt.Sprintf("invalid comparer function: %T", f))
}
opt := option{op: &comparer{v}}
if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
opt.typeFilter = ti
}
return opt
}
type comparer struct {
fnc reflect.Value // func(T, T) bool
}
// AllowUnexported returns an Option that forcibly allows operations on
// unexported fields in certain structs, which are specified by passing in a
// value of each struct type.
//
// Users of this option must understand that comparing on unexported fields
// from external packages is not safe since changes in the internal
// implementation of some external package may cause the result of Equal
// to unexpectedly change. However, it may be valid to use this option on types
// defined in an internal package where the semantic meaning of an unexported
// field is in the control of the user.
//
// For some cases, a custom Comparer should be used instead that defines
// equality as a function of the public API of a type rather than the underlying
// unexported implementation.
//
// For example, the reflect.Type documentation defines equality to be determined
// by the == operator on | {
return "<unknown>"
} | conditional_block |
combat.rs | 20);
NewState::Player
}
pub fn ranged_attack(
ecs: &mut World,
map: &mut Map,
attacker: Entity,
victim: Entity,
ranged_power: i32,
) {
let mut attacker_pos = None;
let mut victim_pos = None;
// Find positions for the start and end
if let Ok(ae) = ecs.entry_ref(attacker) {
if let Ok(pos) = ae.get_component::<Position>() {
attacker_pos = Some(pos.clone());
}
}
if let Ok(ae) = ecs.entry_ref(victim) {
if let Ok(pos) = ae.get_component::<Position>() {
victim_pos = Some(pos.clone());
}
}
if attacker_pos.is_none() || victim_pos.is_none() {
return;
}
let attacker_pos = attacker_pos.unwrap();
let victim_pos = victim_pos.unwrap();
// Set state for the projectile path
let mut power = ranged_power;
let mut range = 0;
let mut projectile_path = Vec::new();
let mut splatter = None;
let mut commands = CommandBuffer::new(ecs);
let current_layer = attacker_pos.layer;
// Map of entity locations. Rebuilt every time because it might change.
let pos_map = <(&Position, &Health)>::query()
.iter(ecs)
.map(|(pos, _)| pos.pt)
.collect::<HashSet<Point>>();
// Plot the initial trajectory
line2d_bresenham(attacker_pos.pt, victim_pos.pt)
.iter()
.skip(1)
.for_each(|pt| {
projectile_path.push(*pt);
if pos_map.contains(&pt) {
power -=
hit_tile_contents(ecs, *pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(*pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
}
}
});
// The trajectory can continue if we have power left
use ultraviolet::Vec2;
let mut projectile_pos: Vec2 = Vec2::new(victim_pos.pt.x as f32, victim_pos.pt.y as f32);
let slope = (projectile_pos - Vec2::new(attacker_pos.pt.x as f32, attacker_pos.pt.y as f32))
.normalized();
while range < 25 && power > 0 {
projectile_pos += slope;
let pt = Point::new(projectile_pos.x as i32, projectile_pos.y as i32);
projectile_path.push(pt);
if pos_map.contains(&pt) {
power -= hit_tile_contents(ecs, pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
let idx = map.get_current().point2d_to_index(pt);
if map.get_current().tiles[idx].tile_type == TileType::Wall {
range += 100;
power = 0;
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
range += 100;
}
}
}
commands.push((
Projectile {
path: projectile_path,
layer: current_layer as usize,
},
Glyph {
glyph: to_cp437('*'),
color: ColorPair::new(RED, BLACK),
},
));
commands.flush(ecs);
}
pub fn hit_tile_contents(
ecs: &mut World,
pt: Point,
layer: u32,
commands: &mut CommandBuffer,
splatter: &mut Option<RGB>,
power: i32,
) -> i32 {
let mut rng_lock = crate::RNG.lock();
let rng = rng_lock.as_mut().unwrap();
let mut power_loss = 0;
let mut dead_entities = Vec::new();
<(Entity, &Position, &mut Health)>::query()
.iter_mut(ecs)
.filter(|(_, pos, _)| pos.layer == layer && pos.pt == pt)
.for_each(|(entity, _, hp)| {
power_loss += hp.current;
if power_loss < 0 {
power_loss = 0;
}
let damage = i32::max(0, power + rng.roll_dice(1, 4) - 2);
//println!("{}", damage);
hp.current -= damage;
if hp.current < 0 {
hp.current = 0;
dead_entities.push(*entity);
}
});
dead_entities.iter().for_each(|e| {
if let Ok(er) = ecs.entry_ref(*e) {
if let Ok(boom) = er.get_component::<Explosive>() {
if let Ok(pos) = er.get_component::<Position>() {
commands.push((
Position::with_pt(pos.pt, pos.layer),
Boom { range: boom.range },
));
}
}
}
});
kill_things(ecs, commands, dead_entities, splatter);
power_loss
}
pub fn melee(ecs: &mut World, map: &mut Map, attacker: Entity, victim: Entity, melee_power: i32) {
// Check range and validity
let mut attacker_pos = None;
let mut defender_pos = None;
if let Ok(e) = ecs.entry_ref(attacker) {
if let Ok(pos) = e.get_component::<Position>() {
attacker_pos = Some(*pos);
}
}
if let Ok(e) = ecs.entry_ref(victim) {
if let Ok(pos) = e.get_component::<Position>() {
defender_pos = Some(*pos);
}
}
if attacker_pos.is_none() || defender_pos.is_none() {
return; // Bail out - invalid data arrived
}
let apos = attacker_pos.unwrap();
let dpos = defender_pos.unwrap();
if apos.layer != dpos.layer {
return; // Bail out - can't attack across layers
}
let d = DistanceAlg::Pythagoras.distance2d(apos.pt, dpos.pt);
if d > 1.5 {
return; // Too far away, bail
}
// Inflict damage upon the hapless victim
let mut dead_entities = Vec::new();
if let Ok(mut v) = ecs.entry_mut(victim) {
if let Ok(hp) = v.get_component_mut::<Health>() {
hp.current = i32::max(0, hp.current - melee_power);
if hp.current == 0 {
dead_entities.push(victim);
}
}
if let Ok(blood) = v.get_component::<Blood>() {
let idx = map.get_layer(dpos.layer as usize).point2d_to_index(dpos.pt);
map.get_layer_mut(dpos.layer as usize).tiles[idx].color.fg = blood.0.into();
}
}
// If necessary, kill them.
let mut commands = CommandBuffer::new(ecs);
let mut splatter = None;
kill_things(ecs, &mut commands, dead_entities, &mut splatter);
// Splatter blood. It's good for you.
}
fn | (
ecs: &mut World,
commands: &mut CommandBuffer,
dead_entities: Vec<Entity>,
splatter: &mut Option<RGB>,
) {
dead_entities.iter().for_each(|entity| {
crate::stats::record_death();
let mut was_decor = false;
let mut was_player = false;
if let Ok(mut er) = ecs.entry_mut(*entity) {
let mut was_colonist = false;
| kill_things | identifier_name |
combat.rs | 20);
NewState::Player
}
pub fn ranged_attack(
ecs: &mut World,
map: &mut Map,
attacker: Entity,
victim: Entity,
ranged_power: i32,
) |
// Set state for the projectile path
let mut power = ranged_power;
let mut range = 0;
let mut projectile_path = Vec::new();
let mut splatter = None;
let mut commands = CommandBuffer::new(ecs);
let current_layer = attacker_pos.layer;
// Map of entity locations. Rebuilt every time because it might change.
let pos_map = <(&Position, &Health)>::query()
.iter(ecs)
.map(|(pos, _)| pos.pt)
.collect::<HashSet<Point>>();
// Plot the initial trajectory
line2d_bresenham(attacker_pos.pt, victim_pos.pt)
.iter()
.skip(1)
.for_each(|pt| {
projectile_path.push(*pt);
if pos_map.contains(&pt) {
power -=
hit_tile_contents(ecs, *pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(*pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
}
}
});
// The trajectory can continue if we have power left
use ultraviolet::Vec2;
let mut projectile_pos: Vec2 = Vec2::new(victim_pos.pt.x as f32, victim_pos.pt.y as f32);
let slope = (projectile_pos - Vec2::new(attacker_pos.pt.x as f32, attacker_pos.pt.y as f32))
.normalized();
while range < 25 && power > 0 {
projectile_pos += slope;
let pt = Point::new(projectile_pos.x as i32, projectile_pos.y as i32);
projectile_path.push(pt);
if pos_map.contains(&pt) {
power -= hit_tile_contents(ecs, pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
let idx = map.get_current().point2d_to_index(pt);
if map.get_current().tiles[idx].tile_type == TileType::Wall {
range += 100;
power = 0;
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
range += 100;
}
}
}
commands.push((
Projectile {
path: projectile_path,
layer: current_layer as usize,
},
Glyph {
glyph: to_cp437('*'),
color: ColorPair::new(RED, BLACK),
},
));
commands.flush(ecs);
}
pub fn hit_tile_contents(
ecs: &mut World,
pt: Point,
layer: u32,
commands: &mut CommandBuffer,
splatter: &mut Option<RGB>,
power: i32,
) -> i32 {
let mut rng_lock = crate::RNG.lock();
let rng = rng_lock.as_mut().unwrap();
let mut power_loss = 0;
let mut dead_entities = Vec::new();
<(Entity, &Position, &mut Health)>::query()
.iter_mut(ecs)
.filter(|(_, pos, _)| pos.layer == layer && pos.pt == pt)
.for_each(|(entity, _, hp)| {
power_loss += hp.current;
if power_loss < 0 {
power_loss = 0;
}
let damage = i32::max(0, power + rng.roll_dice(1, 4) - 2);
//println!("{}", damage);
hp.current -= damage;
if hp.current < 0 {
hp.current = 0;
dead_entities.push(*entity);
}
});
dead_entities.iter().for_each(|e| {
if let Ok(er) = ecs.entry_ref(*e) {
if let Ok(boom) = er.get_component::<Explosive>() {
if let Ok(pos) = er.get_component::<Position>() {
commands.push((
Position::with_pt(pos.pt, pos.layer),
Boom { range: boom.range },
));
}
}
}
});
kill_things(ecs, commands, dead_entities, splatter);
power_loss
}
pub fn melee(ecs: &mut World, map: &mut Map, attacker: Entity, victim: Entity, melee_power: i32) {
// Check range and validity
let mut attacker_pos = None;
let mut defender_pos = None;
if let Ok(e) = ecs.entry_ref(attacker) {
if let Ok(pos) = e.get_component::<Position>() {
attacker_pos = Some(*pos);
}
}
if let Ok(e) = ecs.entry_ref(victim) {
if let Ok(pos) = e.get_component::<Position>() {
defender_pos = Some(*pos);
}
}
if attacker_pos.is_none() || defender_pos.is_none() {
return; // Bail out - invalid data arrived
}
let apos = attacker_pos.unwrap();
let dpos = defender_pos.unwrap();
if apos.layer != dpos.layer {
return; // Bail out - can't attack across layers
}
let d = DistanceAlg::Pythagoras.distance2d(apos.pt, dpos.pt);
if d > 1.5 {
return; // Too far away, bail
}
// Inflict damage upon the hapless victim
let mut dead_entities = Vec::new();
if let Ok(mut v) = ecs.entry_mut(victim) {
if let Ok(hp) = v.get_component_mut::<Health>() {
hp.current = i32::max(0, hp.current - melee_power);
if hp.current == 0 {
dead_entities.push(victim);
}
}
if let Ok(blood) = v.get_component::<Blood>() {
let idx = map.get_layer(dpos.layer as usize).point2d_to_index(dpos.pt);
map.get_layer_mut(dpos.layer as usize).tiles[idx].color.fg = blood.0.into();
}
}
// If necessary, kill them.
let mut commands = CommandBuffer::new(ecs);
let mut splatter = None;
kill_things(ecs, &mut commands, dead_entities, &mut splatter);
// Splatter blood. It's good for you.
}
fn kill_things(
ecs: &mut World,
commands: &mut CommandBuffer,
dead_entities: Vec<Entity>,
splatter: &mut Option<RGB>,
) {
dead_entities.iter().for_each(|entity| {
crate::stats::record_death();
let mut was_decor = false;
let mut was_player = false;
if let Ok(mut er) = ecs.entry_mut(*entity) {
let mut was_colonist = false;
| {
let mut attacker_pos = None;
let mut victim_pos = None;
// Find positions for the start and end
if let Ok(ae) = ecs.entry_ref(attacker) {
if let Ok(pos) = ae.get_component::<Position>() {
attacker_pos = Some(pos.clone());
}
}
if let Ok(ae) = ecs.entry_ref(victim) {
if let Ok(pos) = ae.get_component::<Position>() {
victim_pos = Some(pos.clone());
}
}
if attacker_pos.is_none() || victim_pos.is_none() {
return;
}
let attacker_pos = attacker_pos.unwrap();
let victim_pos = victim_pos.unwrap(); | identifier_body |
combat.rs | 20);
NewState::Player
}
pub fn ranged_attack(
ecs: &mut World,
map: &mut Map,
attacker: Entity,
victim: Entity,
ranged_power: i32,
) {
let mut attacker_pos = None;
let mut victim_pos = None;
// Find positions for the start and end
if let Ok(ae) = ecs.entry_ref(attacker) {
if let Ok(pos) = ae.get_component::<Position>() {
attacker_pos = Some(pos.clone());
}
}
if let Ok(ae) = ecs.entry_ref(victim) {
if let Ok(pos) = ae.get_component::<Position>() {
victim_pos = Some(pos.clone());
}
}
if attacker_pos.is_none() || victim_pos.is_none() {
return;
}
let attacker_pos = attacker_pos.unwrap();
let victim_pos = victim_pos.unwrap();
// Set state for the projectile path
let mut power = ranged_power;
let mut range = 0;
let mut projectile_path = Vec::new();
let mut splatter = None;
let mut commands = CommandBuffer::new(ecs);
let current_layer = attacker_pos.layer;
// Map of entity locations. Rebuilt every time because it might change.
let pos_map = <(&Position, &Health)>::query()
.iter(ecs)
.map(|(pos, _)| pos.pt)
.collect::<HashSet<Point>>();
// Plot the initial trajectory
line2d_bresenham(attacker_pos.pt, victim_pos.pt)
.iter()
.skip(1)
.for_each(|pt| {
projectile_path.push(*pt);
if pos_map.contains(&pt) {
power -=
hit_tile_contents(ecs, *pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(*pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
}
}
});
// The trajectory can continue if we have power left
use ultraviolet::Vec2;
let mut projectile_pos: Vec2 = Vec2::new(victim_pos.pt.x as f32, victim_pos.pt.y as f32);
let slope = (projectile_pos - Vec2::new(attacker_pos.pt.x as f32, attacker_pos.pt.y as f32))
.normalized();
while range < 25 && power > 0 {
projectile_pos += slope;
let pt = Point::new(projectile_pos.x as i32, projectile_pos.y as i32);
projectile_path.push(pt);
if pos_map.contains(&pt) {
power -= hit_tile_contents(ecs, pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
let idx = map.get_current().point2d_to_index(pt);
if map.get_current().tiles[idx].tile_type == TileType::Wall {
range += 100;
power = 0;
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
range += 100;
}
}
}
commands.push((
Projectile {
path: projectile_path,
layer: current_layer as usize,
},
Glyph {
glyph: to_cp437('*'),
color: ColorPair::new(RED, BLACK),
},
));
commands.flush(ecs);
}
pub fn hit_tile_contents(
ecs: &mut World,
pt: Point,
layer: u32,
commands: &mut CommandBuffer,
splatter: &mut Option<RGB>,
power: i32,
) -> i32 {
let mut rng_lock = crate::RNG.lock();
let rng = rng_lock.as_mut().unwrap();
let mut power_loss = 0;
let mut dead_entities = Vec::new();
<(Entity, &Position, &mut Health)>::query()
.iter_mut(ecs)
.filter(|(_, pos, _)| pos.layer == layer && pos.pt == pt)
.for_each(|(entity, _, hp)| {
power_loss += hp.current;
if power_loss < 0 {
power_loss = 0;
}
let damage = i32::max(0, power + rng.roll_dice(1, 4) - 2);
//println!("{}", damage);
hp.current -= damage;
if hp.current < 0 {
hp.current = 0;
dead_entities.push(*entity);
}
});
dead_entities.iter().for_each(|e| {
if let Ok(er) = ecs.entry_ref(*e) {
if let Ok(boom) = er.get_component::<Explosive>() {
if let Ok(pos) = er.get_component::<Position>() {
commands.push((
Position::with_pt(pos.pt, pos.layer),
Boom { range: boom.range },
));
}
}
}
});
kill_things(ecs, commands, dead_entities, splatter);
power_loss
}
pub fn melee(ecs: &mut World, map: &mut Map, attacker: Entity, victim: Entity, melee_power: i32) {
// Check range and validity
let mut attacker_pos = None;
let mut defender_pos = None;
if let Ok(e) = ecs.entry_ref(attacker) {
if let Ok(pos) = e.get_component::<Position>() {
attacker_pos = Some(*pos);
}
}
if let Ok(e) = ecs.entry_ref(victim) {
if let Ok(pos) = e.get_component::<Position>() {
defender_pos = Some(*pos);
}
}
if attacker_pos.is_none() || defender_pos.is_none() {
return; // Bail out - invalid data arrived
}
let apos = attacker_pos.unwrap();
let dpos = defender_pos.unwrap();
if apos.layer != dpos.layer {
return; // Bail out - can't attack across layers
}
let d = DistanceAlg::Pythagoras.distance2d(apos.pt, dpos.pt);
if d > 1.5 {
return; // Too far away, bail
}
// Inflict damage upon the hapless victim
let mut dead_entities = Vec::new();
if let Ok(mut v) = ecs.entry_mut(victim) |
// If necessary, kill them.
let mut commands = CommandBuffer::new(ecs);
let mut splatter = None;
kill_things(ecs, &mut commands, dead_entities, &mut splatter);
// Splatter blood. It's good for you.
}
fn kill_things(
ecs: &mut World,
commands: &mut CommandBuffer,
dead_entities: Vec<Entity>,
splatter: &mut Option<RGB>,
) {
dead_entities.iter().for_each(|entity| {
crate::stats::record_death();
let mut was_decor = false;
let mut was_player = false;
if let Ok(mut er) = ecs.entry_mut(*entity) {
let mut was_colonist = false;
| {
if let Ok(hp) = v.get_component_mut::<Health>() {
hp.current = i32::max(0, hp.current - melee_power);
if hp.current == 0 {
dead_entities.push(victim);
}
}
if let Ok(blood) = v.get_component::<Blood>() {
let idx = map.get_layer(dpos.layer as usize).point2d_to_index(dpos.pt);
map.get_layer_mut(dpos.layer as usize).tiles[idx].color.fg = blood.0.into();
}
} | conditional_block |
combat.rs | 20);
NewState::Player
}
pub fn ranged_attack(
ecs: &mut World,
map: &mut Map,
attacker: Entity,
victim: Entity,
ranged_power: i32,
) {
let mut attacker_pos = None;
let mut victim_pos = None;
// Find positions for the start and end
if let Ok(ae) = ecs.entry_ref(attacker) {
if let Ok(pos) = ae.get_component::<Position>() {
attacker_pos = Some(pos.clone());
}
}
if let Ok(ae) = ecs.entry_ref(victim) {
if let Ok(pos) = ae.get_component::<Position>() {
victim_pos = Some(pos.clone());
}
}
if attacker_pos.is_none() || victim_pos.is_none() {
return;
}
let attacker_pos = attacker_pos.unwrap();
let victim_pos = victim_pos.unwrap();
// Set state for the projectile path
let mut power = ranged_power;
let mut range = 0;
let mut projectile_path = Vec::new();
let mut splatter = None;
let mut commands = CommandBuffer::new(ecs);
let current_layer = attacker_pos.layer;
// Map of entity locations. Rebuilt every time because it might change.
let pos_map = <(&Position, &Health)>::query()
.iter(ecs)
.map(|(pos, _)| pos.pt)
.collect::<HashSet<Point>>();
// Plot the initial trajectory
line2d_bresenham(attacker_pos.pt, victim_pos.pt)
.iter()
.skip(1)
.for_each(|pt| {
projectile_path.push(*pt);
if pos_map.contains(&pt) {
power -=
hit_tile_contents(ecs, *pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(*pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
}
}
});
// The trajectory can continue if we have power left
use ultraviolet::Vec2;
let mut projectile_pos: Vec2 = Vec2::new(victim_pos.pt.x as f32, victim_pos.pt.y as f32);
let slope = (projectile_pos - Vec2::new(attacker_pos.pt.x as f32, attacker_pos.pt.y as f32))
.normalized();
while range < 25 && power > 0 {
projectile_pos += slope;
let pt = Point::new(projectile_pos.x as i32, projectile_pos.y as i32);
projectile_path.push(pt);
if pos_map.contains(&pt) {
power -= hit_tile_contents(ecs, pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
let idx = map.get_current().point2d_to_index(pt);
if map.get_current().tiles[idx].tile_type == TileType::Wall {
range += 100;
power = 0;
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
range += 100;
}
}
}
commands.push((
Projectile {
path: projectile_path, | },
Glyph {
glyph: to_cp437('*'),
color: ColorPair::new(RED, BLACK),
},
));
commands.flush(ecs);
}
pub fn hit_tile_contents(
ecs: &mut World,
pt: Point,
layer: u32,
commands: &mut CommandBuffer,
splatter: &mut Option<RGB>,
power: i32,
) -> i32 {
let mut rng_lock = crate::RNG.lock();
let rng = rng_lock.as_mut().unwrap();
let mut power_loss = 0;
let mut dead_entities = Vec::new();
<(Entity, &Position, &mut Health)>::query()
.iter_mut(ecs)
.filter(|(_, pos, _)| pos.layer == layer && pos.pt == pt)
.for_each(|(entity, _, hp)| {
power_loss += hp.current;
if power_loss < 0 {
power_loss = 0;
}
let damage = i32::max(0, power + rng.roll_dice(1, 4) - 2);
//println!("{}", damage);
hp.current -= damage;
if hp.current < 0 {
hp.current = 0;
dead_entities.push(*entity);
}
});
dead_entities.iter().for_each(|e| {
if let Ok(er) = ecs.entry_ref(*e) {
if let Ok(boom) = er.get_component::<Explosive>() {
if let Ok(pos) = er.get_component::<Position>() {
commands.push((
Position::with_pt(pos.pt, pos.layer),
Boom { range: boom.range },
));
}
}
}
});
kill_things(ecs, commands, dead_entities, splatter);
power_loss
}
pub fn melee(ecs: &mut World, map: &mut Map, attacker: Entity, victim: Entity, melee_power: i32) {
// Check range and validity
let mut attacker_pos = None;
let mut defender_pos = None;
if let Ok(e) = ecs.entry_ref(attacker) {
if let Ok(pos) = e.get_component::<Position>() {
attacker_pos = Some(*pos);
}
}
if let Ok(e) = ecs.entry_ref(victim) {
if let Ok(pos) = e.get_component::<Position>() {
defender_pos = Some(*pos);
}
}
if attacker_pos.is_none() || defender_pos.is_none() {
return; // Bail out - invalid data arrived
}
let apos = attacker_pos.unwrap();
let dpos = defender_pos.unwrap();
if apos.layer != dpos.layer {
return; // Bail out - can't attack across layers
}
let d = DistanceAlg::Pythagoras.distance2d(apos.pt, dpos.pt);
if d > 1.5 {
return; // Too far away, bail
}
// Inflict damage upon the hapless victim
let mut dead_entities = Vec::new();
if let Ok(mut v) = ecs.entry_mut(victim) {
if let Ok(hp) = v.get_component_mut::<Health>() {
hp.current = i32::max(0, hp.current - melee_power);
if hp.current == 0 {
dead_entities.push(victim);
}
}
if let Ok(blood) = v.get_component::<Blood>() {
let idx = map.get_layer(dpos.layer as usize).point2d_to_index(dpos.pt);
map.get_layer_mut(dpos.layer as usize).tiles[idx].color.fg = blood.0.into();
}
}
// If necessary, kill them.
let mut commands = CommandBuffer::new(ecs);
let mut splatter = None;
kill_things(ecs, &mut commands, dead_entities, &mut splatter);
// Splatter blood. It's good for you.
}
fn kill_things(
ecs: &mut World,
commands: &mut CommandBuffer,
dead_entities: Vec<Entity>,
splatter: &mut Option<RGB>,
) {
dead_entities.iter().for_each(|entity| {
crate::stats::record_death();
let mut was_decor = false;
let mut was_player = false;
if let Ok(mut er) = ecs.entry_mut(*entity) {
let mut was_colonist = false;
if | layer: current_layer as usize, | random_line_split |
tutor-details.component.ts | requestPermissions:{google:['https://www.googleapis.com/auth/calendar']}, forceApprovalPrompt: {google: true}, requestOfflineToken: {google: true}});
Stripe.setPublishableKey(Meteor.settings.public.stripe.livePublishableKey);
var handler = StripeCheckout.configure({
key: Meteor.settings.public.stripe.testPublishableKey,
token: function(token) {}
});
});
@Component({
selector: 'tutor-details',
template,
styles: [ style ]
})
@InjectUser('user')
export class TutorDetailsComponentUser implements OnInit, OnDestroy {
loggedIn:boolean=true;
user_skype_email: string;
today: Date = new Date();
today_show: Date = new Date();
tutorId: string;
slot: number;
color: string[]= new Array(24);
day: number=1;
tutorAsUserId: string;
tutor: Tutor;
paramsSub: Subscription;
imagesSubs: Subscription;
classesSub: Subscription;
reqSub: Subscription;
tutorSub: Subscription;
requests: Observable<Request[]>;
mailtoTutor: string;
tutor_user_email: string;
class: Class_;
tutorClasses: Observable<Class_[]>;
user: Meteor.User;
checkout: boolean=false;
a_day: number[] = new Array(24);
tutorSchedule: number[][] = new Array();
colorsSched: string[][] = new Array();
range_for_disp: number[] = new Array(12);
amount: number=0;
checkDetails: string[]=new Array(3);
payment_form: FormGroup;
payment_form_2: FormGroup;
submitted: boolean = false;
g_calendar: boolean=false;
// cc
cardNumber: string;
expiryMonth: string;
expiryYear: string;
cvc: string;
constructor(
private router: Router,
private formBuilder: FormBuilder,
private route: ActivatedRoute
) |
private myDatePickerOptions: IMyOptions = {
// other options...
dateFormat: 'dd.mm.yyyy',
inline: true,
disableDateRanges: [{ begin: {year: this.today.getFullYear(), month: this.today.getMonth()-2, day: this.today.getDate()}, end: {year: this.today.getFullYear(),
month: this.today.getMonth()+1, day: this.today.getDate()-1} },{ begin: {year: this.today.getFullYear(),month: this.today.getMonth()+1, day: this.today.getDate()+7},
end: {year: this.today.getFullYear(),month: this.today.getMonth()+2, day: this.today.getDate()} }]
};
// Initialized to specific date (09.10.2018).
private model: Object = { date: { year: 2018, month: 10, day: 9 } };
ngOnInit() {
console.log(Meteor.userId());
if(!Meteor.userId()){
this.loggedIn=false;
Bert.alert( 'You need to be logged in to view this page', 'danger', 'fixed-bottom' );
this.router.navigate('/login');
}
this.imagesSubs = MeteorObservable.subscribe('images').subscribe();
this.payment_form_2 = this.formBuilder.group({
creditCard: ['', [<any>CreditCardValidator.validateCCNumber]],
expDate: ['', [<any>CreditCardValidator.validateExpDate]],
cvc: ['', [<any>Validators.required, <any>Validators.minLength(3), <any>Validators.maxLength(4)]]
});
this.payment_form = this.formBuilder.group({
cardNumber: ['', Validators.required],
expiryMonth: ['', Validators.required],
expiryYear: ['', Validators.required],
cvc: ['', Validators.required]
});
for (var i = 0; i < 24; i++) {
this.color[i]='green';
}
for (var i = 0; i < 7; i++) {
this.colorsSched[i]=this.color;
}
this.paramsSub = this.route.params
.map(params => params['tutorId'])
.subscribe(tutorId => {
this.tutorId = tutorId;
if (this.tutorSub) {
this.tutorSub.unsubscribe();
}
});
this.tutorSub = MeteorObservable.subscribe('tutors').subscribe(() => {
this.tutor=Tutors.findOne(this.tutorId);
this.tutorAsUserId=this.tutor.userId;
this.tutorSchedule=this.tutor.times;
this.amount = this.tutor.hourly_rating;
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(this.tutor.lastUpdateDate.getFullYear(), this.tutor.lastUpdateDate.getMonth(), this.tutor.lastUpdateDate.getDate());
let last_update_diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
for (var i = 0; i < last_update_diff; i++) {
for(var j = 0; j < 24; j++) {
this.colorsSched[i][j]='blue';
}
}
for (var i = last_update_diff; i < 7; i++) {
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='blue';
}else{
this.colorsSched[i][j]='green';
}
}
}
// console.log(this.colorsSched);
});
console.log(this.colorsSched);
this.tutorSub = MeteorObservable.subscribe('users').subscribe(() => {
this.tutor_user_email=Users.findOne(this.tutorAsUserId).emails[0].address;
this.mailtoTutor="mailto:"+ this.tutor_user_email;
});
//TODO only find classes that this tutor do 34064745
this.classesSub = MeteorObservable.subscribe('classes').subscribe(() => {
this.tutorClasses = Classes.find({tutorId: {$eq: this.tutorAsUserId} });
});
}
get isMe(): boolean {
if(this.user)
return this.user._id === this.tutorAsUserId;
return false;
}
toggleSlot(i: number): void {
this.today_show.setHours(i,0,0);
this.slot = i;
console.log(this.tutorSchedule[this.day][i]);
if(this.tutorSchedule[this.day][i]==0){
this.tutorSchedule[this.day][i]=1;
this.colorsSched[this.day][i]='green';
}else if(this.tutorSchedule[this.day][i]==1){
this.tutorSchedule[this.day][i]=0;
this.colorsSched[this.day][i]='blue';
}
// else if(this.colorsSched[this.day][i]='blue'){
// this.colorsSched[this.day][i]='green';
// }
}
onDateChanged(event: IMyDateModel) {
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(event.jsdate.getFullYear(), event.jsdate.getMonth(), event.jsdate.getDate());
let diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
let i = diff;
this.day = diff;
this.today_show.setDate(this.today.getDate()+i);
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='green';
}else{
this.colorsSched[i][j]='red';
}
}
}
CheckoutFn():void{
if (this.payment_form.valid) {
console.log('payment form valid')
Stripe.card.createToken({
number: this.payment_form.value.cardNumber,
cvc: this.payment_form.value.cvc,
exp_month: this.payment_form.value.expiryMonth,
exp_year: this.payment_form.value.expiryYear
}, function(status, response) {
console.log(status);
console.log(response.error.message);
stripeToken = response.id;
Meteor.call('chargeCard', stripeToken, amount);
});
}
}
step1(): void{
this.checkout = false;
}
GoToCheckOut(): void{
// if(!this.user_skype_email){
// alert('Please enter your skype username so the teatch can contact you :)');
// }else{
// alert('you are now registered in this class :)');
// }
console.log(this.slot);
console.log(this.tutorSchedule)
this.tutorSchedule[this.day][this.slot]=2;
// Tutors.update(this.tutorId, {
// $set:{times: this.tutorSchedule }
// });
this.checkout=true;
}
onSubmit() {
let success= false;
let free= true;
if (this.payment_form_2.valid) {
this.submitted = true;
let m = this.payment_form_2.value.expDate[0]+this.payment_form_2.value.expDate[1];
let y = this.payment_form_2.value.expDate[5 | {} | identifier_body |
tutor-details.component.ts | ({requestPermissions:{google:['https://www.googleapis.com/auth/calendar']}, forceApprovalPrompt: {google: true}, requestOfflineToken: {google: true}});
Stripe.setPublishableKey(Meteor.settings.public.stripe.livePublishableKey);
var handler = StripeCheckout.configure({
key: Meteor.settings.public.stripe.testPublishableKey,
token: function(token) {}
});
});
@Component({
selector: 'tutor-details',
template,
styles: [ style ]
})
@InjectUser('user')
export class TutorDetailsComponentUser implements OnInit, OnDestroy {
loggedIn:boolean=true;
user_skype_email: string;
today: Date = new Date();
today_show: Date = new Date();
tutorId: string;
slot: number;
color: string[]= new Array(24);
day: number=1;
tutorAsUserId: string;
tutor: Tutor;
paramsSub: Subscription;
imagesSubs: Subscription;
classesSub: Subscription;
reqSub: Subscription;
tutorSub: Subscription;
requests: Observable<Request[]>;
mailtoTutor: string;
tutor_user_email: string;
class: Class_;
tutorClasses: Observable<Class_[]>;
user: Meteor.User;
checkout: boolean=false;
a_day: number[] = new Array(24);
tutorSchedule: number[][] = new Array();
colorsSched: string[][] = new Array();
range_for_disp: number[] = new Array(12);
amount: number=0;
checkDetails: string[]=new Array(3);
payment_form: FormGroup;
payment_form_2: FormGroup;
submitted: boolean = false;
g_calendar: boolean=false;
// cc
cardNumber: string;
expiryMonth: string;
expiryYear: string;
cvc: string;
constructor(
private router: Router,
private formBuilder: FormBuilder,
private route: ActivatedRoute
) {}
private myDatePickerOptions: IMyOptions = {
// other options...
dateFormat: 'dd.mm.yyyy',
inline: true,
disableDateRanges: [{ begin: {year: this.today.getFullYear(), month: this.today.getMonth()-2, day: this.today.getDate()}, end: {year: this.today.getFullYear(),
month: this.today.getMonth()+1, day: this.today.getDate()-1} },{ begin: {year: this.today.getFullYear(),month: this.today.getMonth()+1, day: this.today.getDate()+7},
end: {year: this.today.getFullYear(),month: this.today.getMonth()+2, day: this.today.getDate()} }]
};
// Initialized to specific date (09.10.2018).
private model: Object = { date: { year: 2018, month: 10, day: 9 } };
ngOnInit() {
console.log(Meteor.userId());
if(!Meteor.userId()){
this.loggedIn=false;
Bert.alert( 'You need to be logged in to view this page', 'danger', 'fixed-bottom' );
this.router.navigate('/login');
}
this.imagesSubs = MeteorObservable.subscribe('images').subscribe();
this.payment_form_2 = this.formBuilder.group({
creditCard: ['', [<any>CreditCardValidator.validateCCNumber]],
expDate: ['', [<any>CreditCardValidator.validateExpDate]],
cvc: ['', [<any>Validators.required, <any>Validators.minLength(3), <any>Validators.maxLength(4)]]
});
this.payment_form = this.formBuilder.group({
cardNumber: ['', Validators.required],
expiryMonth: ['', Validators.required],
expiryYear: ['', Validators.required],
cvc: ['', Validators.required]
});
for (var i = 0; i < 24; i++) {
this.color[i]='green';
}
for (var i = 0; i < 7; i++) {
this.colorsSched[i]=this.color;
}
this.paramsSub = this.route.params
.map(params => params['tutorId'])
.subscribe(tutorId => {
this.tutorId = tutorId;
if (this.tutorSub) {
this.tutorSub.unsubscribe();
}
});
this.tutorSub = MeteorObservable.subscribe('tutors').subscribe(() => {
this.tutor=Tutors.findOne(this.tutorId);
this.tutorAsUserId=this.tutor.userId;
this.tutorSchedule=this.tutor.times;
this.amount = this.tutor.hourly_rating;
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(this.tutor.lastUpdateDate.getFullYear(), this.tutor.lastUpdateDate.getMonth(), this.tutor.lastUpdateDate.getDate());
let last_update_diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
for (var i = 0; i < last_update_diff; i++) {
for(var j = 0; j < 24; j++) {
this.colorsSched[i][j]='blue';
}
}
for (var i = last_update_diff; i < 7; i++) {
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='blue';
}else{
this.colorsSched[i][j]='green';
}
}
}
// console.log(this.colorsSched);
});
console.log(this.colorsSched);
this.tutorSub = MeteorObservable.subscribe('users').subscribe(() => {
this.tutor_user_email=Users.findOne(this.tutorAsUserId).emails[0].address;
this.mailtoTutor="mailto:"+ this.tutor_user_email;
});
//TODO only find classes that this tutor do 34064745
this.classesSub = MeteorObservable.subscribe('classes').subscribe(() => {
this.tutorClasses = Classes.find({tutorId: {$eq: this.tutorAsUserId} });
});
}
get isMe(): boolean {
if(this.user)
return this.user._id === this.tutorAsUserId;
return false;
}
toggleSlot(i: number): void {
this.today_show.setHours(i,0,0);
this.slot = i;
console.log(this.tutorSchedule[this.day][i]);
if(this.tutorSchedule[this.day][i]==0){
this.tutorSchedule[this.day][i]=1;
this.colorsSched[this.day][i]='green';
}else if(this.tutorSchedule[this.day][i]==1){
this.tutorSchedule[this.day][i]=0;
this.colorsSched[this.day][i]='blue';
}
// else if(this.colorsSched[this.day][i]='blue'){
// this.colorsSched[this.day][i]='green';
// }
}
onDateChanged(event: IMyDateModel) {
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(event.jsdate.getFullYear(), event.jsdate.getMonth(), event.jsdate.getDate());
let diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
let i = diff;
this.day = diff;
this.today_show.setDate(this.today.getDate()+i);
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='green';
}else{
this.colorsSched[i][j]='red';
}
}
}
CheckoutFn():void{
if (this.payment_form.valid) {
console.log('payment form valid')
Stripe.card.createToken({
number: this.payment_form.value.cardNumber,
cvc: this.payment_form.value.cvc,
exp_month: this.payment_form.value.expiryMonth,
exp_year: this.payment_form.value.expiryYear
}, function(status, response) {
console.log(status);
console.log(response.error.message);
stripeToken = response.id;
Meteor.call('chargeCard', stripeToken, amount);
});
}
}
| (): void{
this.checkout = false;
}
GoToCheckOut(): void{
// if(!this.user_skype_email){
// alert('Please enter your skype username so the teatch can contact you :)');
// }else{
// alert('you are now registered in this class :)');
// }
console.log(this.slot);
console.log(this.tutorSchedule)
this.tutorSchedule[this.day][this.slot]=2;
// Tutors.update(this.tutorId, {
// $set:{times: this.tutorSchedule }
// });
this.checkout=true;
}
onSubmit() {
let success= false;
let free= true;
if (this.payment_form_2.valid) {
this.submitted = true;
let m = this.payment_form_2.value.expDate[0]+this.payment_form_2.value.expDate[1];
let y = this.payment_form_2.value.expDate[5]+ | step1 | identifier_name |
tutor-details.component.ts | requestPermissions:{google:['https://www.googleapis.com/auth/calendar']}, forceApprovalPrompt: {google: true}, requestOfflineToken: {google: true}});
Stripe.setPublishableKey(Meteor.settings.public.stripe.livePublishableKey);
var handler = StripeCheckout.configure({
key: Meteor.settings.public.stripe.testPublishableKey,
token: function(token) {}
});
});
@Component({
selector: 'tutor-details',
template,
styles: [ style ]
})
@InjectUser('user')
export class TutorDetailsComponentUser implements OnInit, OnDestroy {
loggedIn:boolean=true;
user_skype_email: string;
today: Date = new Date();
today_show: Date = new Date();
tutorId: string;
slot: number;
color: string[]= new Array(24);
day: number=1;
tutorAsUserId: string;
tutor: Tutor;
paramsSub: Subscription;
imagesSubs: Subscription;
classesSub: Subscription;
reqSub: Subscription;
tutorSub: Subscription;
requests: Observable<Request[]>;
mailtoTutor: string;
tutor_user_email: string;
class: Class_;
tutorClasses: Observable<Class_[]>;
user: Meteor.User;
checkout: boolean=false;
a_day: number[] = new Array(24);
tutorSchedule: number[][] = new Array();
colorsSched: string[][] = new Array();
range_for_disp: number[] = new Array(12);
amount: number=0;
checkDetails: string[]=new Array(3);
payment_form: FormGroup;
payment_form_2: FormGroup;
submitted: boolean = false;
g_calendar: boolean=false;
// cc
cardNumber: string;
expiryMonth: string;
expiryYear: string;
cvc: string;
constructor(
private router: Router,
private formBuilder: FormBuilder,
private route: ActivatedRoute
) {}
private myDatePickerOptions: IMyOptions = {
// other options...
dateFormat: 'dd.mm.yyyy',
inline: true,
disableDateRanges: [{ begin: {year: this.today.getFullYear(), month: this.today.getMonth()-2, day: this.today.getDate()}, end: {year: this.today.getFullYear(),
month: this.today.getMonth()+1, day: this.today.getDate()-1} },{ begin: {year: this.today.getFullYear(),month: this.today.getMonth()+1, day: this.today.getDate()+7},
end: {year: this.today.getFullYear(),month: this.today.getMonth()+2, day: this.today.getDate()} }]
};
// Initialized to specific date (09.10.2018).
private model: Object = { date: { year: 2018, month: 10, day: 9 } };
ngOnInit() {
console.log(Meteor.userId());
if(!Meteor.userId()){
this.loggedIn=false;
Bert.alert( 'You need to be logged in to view this page', 'danger', 'fixed-bottom' );
this.router.navigate('/login');
}
this.imagesSubs = MeteorObservable.subscribe('images').subscribe();
this.payment_form_2 = this.formBuilder.group({
creditCard: ['', [<any>CreditCardValidator.validateCCNumber]],
expDate: ['', [<any>CreditCardValidator.validateExpDate]],
cvc: ['', [<any>Validators.required, <any>Validators.minLength(3), <any>Validators.maxLength(4)]]
});
this.payment_form = this.formBuilder.group({
cardNumber: ['', Validators.required],
expiryMonth: ['', Validators.required],
expiryYear: ['', Validators.required],
cvc: ['', Validators.required]
});
for (var i = 0; i < 24; i++) {
this.color[i]='green';
}
for (var i = 0; i < 7; i++) {
this.colorsSched[i]=this.color;
}
this.paramsSub = this.route.params
.map(params => params['tutorId'])
.subscribe(tutorId => {
this.tutorId = tutorId;
if (this.tutorSub) {
this.tutorSub.unsubscribe();
}
});
this.tutorSub = MeteorObservable.subscribe('tutors').subscribe(() => {
this.tutor=Tutors.findOne(this.tutorId);
this.tutorAsUserId=this.tutor.userId;
this.tutorSchedule=this.tutor.times;
this.amount = this.tutor.hourly_rating;
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(this.tutor.lastUpdateDate.getFullYear(), this.tutor.lastUpdateDate.getMonth(), this.tutor.lastUpdateDate.getDate());
let last_update_diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
for (var i = 0; i < last_update_diff; i++) {
for(var j = 0; j < 24; j++) {
this.colorsSched[i][j]='blue';
}
}
for (var i = last_update_diff; i < 7; i++) {
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='blue';
}else{
this.colorsSched[i][j]='green';
}
}
}
// console.log(this.colorsSched);
});
console.log(this.colorsSched);
this.tutorSub = MeteorObservable.subscribe('users').subscribe(() => {
this.tutor_user_email=Users.findOne(this.tutorAsUserId).emails[0].address;
this.mailtoTutor="mailto:"+ this.tutor_user_email;
});
//TODO only find classes that this tutor do 34064745
this.classesSub = MeteorObservable.subscribe('classes').subscribe(() => {
this.tutorClasses = Classes.find({tutorId: {$eq: this.tutorAsUserId} });
});
}
get isMe(): boolean {
if(this.user)
return this.user._id === this.tutorAsUserId;
return false;
}
toggleSlot(i: number): void {
this.today_show.setHours(i,0,0);
this.slot = i;
console.log(this.tutorSchedule[this.day][i]);
if(this.tutorSchedule[this.day][i]==0) | else if(this.tutorSchedule[this.day][i]==1){
this.tutorSchedule[this.day][i]=0;
this.colorsSched[this.day][i]='blue';
}
// else if(this.colorsSched[this.day][i]='blue'){
// this.colorsSched[this.day][i]='green';
// }
}
onDateChanged(event: IMyDateModel) {
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(event.jsdate.getFullYear(), event.jsdate.getMonth(), event.jsdate.getDate());
let diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
let i = diff;
this.day = diff;
this.today_show.setDate(this.today.getDate()+i);
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='green';
}else{
this.colorsSched[i][j]='red';
}
}
}
CheckoutFn():void{
if (this.payment_form.valid) {
console.log('payment form valid')
Stripe.card.createToken({
number: this.payment_form.value.cardNumber,
cvc: this.payment_form.value.cvc,
exp_month: this.payment_form.value.expiryMonth,
exp_year: this.payment_form.value.expiryYear
}, function(status, response) {
console.log(status);
console.log(response.error.message);
stripeToken = response.id;
Meteor.call('chargeCard', stripeToken, amount);
});
}
}
step1(): void{
this.checkout = false;
}
GoToCheckOut(): void{
// if(!this.user_skype_email){
// alert('Please enter your skype username so the teatch can contact you :)');
// }else{
// alert('you are now registered in this class :)');
// }
console.log(this.slot);
console.log(this.tutorSchedule)
this.tutorSchedule[this.day][this.slot]=2;
// Tutors.update(this.tutorId, {
// $set:{times: this.tutorSchedule }
// });
this.checkout=true;
}
onSubmit() {
let success= false;
let free= true;
if (this.payment_form_2.valid) {
this.submitted = true;
let m = this.payment_form_2.value.expDate[0]+this.payment_form_2.value.expDate[1];
let y = this.payment_form_2.value.expDate[5]+ | {
this.tutorSchedule[this.day][i]=1;
this.colorsSched[this.day][i]='green';
} | conditional_block |
tutor-details.component.ts | ({requestPermissions:{google:['https://www.googleapis.com/auth/calendar']}, forceApprovalPrompt: {google: true}, requestOfflineToken: {google: true}});
Stripe.setPublishableKey(Meteor.settings.public.stripe.livePublishableKey);
var handler = StripeCheckout.configure({
key: Meteor.settings.public.stripe.testPublishableKey,
token: function(token) {}
});
});
@Component({
selector: 'tutor-details',
template,
styles: [ style ]
})
@InjectUser('user')
export class TutorDetailsComponentUser implements OnInit, OnDestroy {
loggedIn:boolean=true;
user_skype_email: string;
today: Date = new Date();
today_show: Date = new Date();
tutorId: string;
slot: number;
color: string[]= new Array(24);
day: number=1;
tutorAsUserId: string;
tutor: Tutor;
paramsSub: Subscription;
imagesSubs: Subscription;
classesSub: Subscription;
reqSub: Subscription;
tutorSub: Subscription;
requests: Observable<Request[]>;
mailtoTutor: string;
tutor_user_email: string;
class: Class_;
tutorClasses: Observable<Class_[]>;
user: Meteor.User;
checkout: boolean=false;
a_day: number[] = new Array(24);
tutorSchedule: number[][] = new Array();
colorsSched: string[][] = new Array();
range_for_disp: number[] = new Array(12);
amount: number=0;
checkDetails: string[]=new Array(3);
payment_form: FormGroup;
payment_form_2: FormGroup;
submitted: boolean = false;
g_calendar: boolean=false;
// cc
cardNumber: string;
expiryMonth: string;
expiryYear: string;
cvc: string;
constructor(
private router: Router,
private formBuilder: FormBuilder,
private route: ActivatedRoute
) {}
private myDatePickerOptions: IMyOptions = {
// other options...
dateFormat: 'dd.mm.yyyy',
inline: true,
disableDateRanges: [{ begin: {year: this.today.getFullYear(), month: this.today.getMonth()-2, day: this.today.getDate()}, end: {year: this.today.getFullYear(),
month: this.today.getMonth()+1, day: this.today.getDate()-1} },{ begin: {year: this.today.getFullYear(),month: this.today.getMonth()+1, day: this.today.getDate()+7},
end: {year: this.today.getFullYear(),month: this.today.getMonth()+2, day: this.today.getDate()} }]
};
// Initialized to specific date (09.10.2018).
private model: Object = { date: { year: 2018, month: 10, day: 9 } };
ngOnInit() {
console.log(Meteor.userId());
if(!Meteor.userId()){
this.loggedIn=false;
Bert.alert( 'You need to be logged in to view this page', 'danger', 'fixed-bottom' );
this.router.navigate('/login');
}
this.imagesSubs = MeteorObservable.subscribe('images').subscribe();
this.payment_form_2 = this.formBuilder.group({
creditCard: ['', [<any>CreditCardValidator.validateCCNumber]],
expDate: ['', [<any>CreditCardValidator.validateExpDate]],
cvc: ['', [<any>Validators.required, <any>Validators.minLength(3), <any>Validators.maxLength(4)]]
});
this.payment_form = this.formBuilder.group({
cardNumber: ['', Validators.required],
expiryMonth: ['', Validators.required],
expiryYear: ['', Validators.required],
cvc: ['', Validators.required]
});
for (var i = 0; i < 24; i++) {
this.color[i]='green';
}
for (var i = 0; i < 7; i++) {
this.colorsSched[i]=this.color;
}
this.paramsSub = this.route.params
.map(params => params['tutorId'])
.subscribe(tutorId => {
this.tutorId = tutorId;
if (this.tutorSub) {
this.tutorSub.unsubscribe();
}
});
this.tutorSub = MeteorObservable.subscribe('tutors').subscribe(() => {
this.tutor=Tutors.findOne(this.tutorId);
this.tutorAsUserId=this.tutor.userId;
this.tutorSchedule=this.tutor.times;
this.amount = this.tutor.hourly_rating;
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(this.tutor.lastUpdateDate.getFullYear(), this.tutor.lastUpdateDate.getMonth(), this.tutor.lastUpdateDate.getDate());
let last_update_diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
for (var i = 0; i < last_update_diff; i++) {
for(var j = 0; j < 24; j++) {
this.colorsSched[i][j]='blue';
}
}
for (var i = last_update_diff; i < 7; i++) {
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='blue';
}else{
this.colorsSched[i][j]='green';
}
}
}
// console.log(this.colorsSched);
});
console.log(this.colorsSched);
this.tutorSub = MeteorObservable.subscribe('users').subscribe(() => {
this.tutor_user_email=Users.findOne(this.tutorAsUserId).emails[0].address;
this.mailtoTutor="mailto:"+ this.tutor_user_email;
});
//TODO only find classes that this tutor do 34064745
this.classesSub = MeteorObservable.subscribe('classes').subscribe(() => {
this.tutorClasses = Classes.find({tutorId: {$eq: this.tutorAsUserId} });
});
}
get isMe(): boolean {
if(this.user)
return this.user._id === this.tutorAsUserId;
return false;
}
toggleSlot(i: number): void {
this.today_show.setHours(i,0,0);
this.slot = i;
console.log(this.tutorSchedule[this.day][i]);
if(this.tutorSchedule[this.day][i]==0){
this.tutorSchedule[this.day][i]=1;
this.colorsSched[this.day][i]='green';
}else if(this.tutorSchedule[this.day][i]==1){
this.tutorSchedule[this.day][i]=0;
this.colorsSched[this.day][i]='blue';
}
// else if(this.colorsSched[this.day][i]='blue'){
// this.colorsSched[this.day][i]='green';
// }
}
onDateChanged(event: IMyDateModel) {
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
let utc1 = Date.UTC(this.today.getFullYear(), this.today.getMonth(), this.today.getDate());
let utc2 = Date.UTC(event.jsdate.getFullYear(), event.jsdate.getMonth(), event.jsdate.getDate());
let diff = Math.floor((utc2 - utc1) / _MS_PER_DAY);
let i = diff;
this.day = diff;
this.today_show.setDate(this.today.getDate()+i);
for(var j = 0; j < 24; j++) {
// console.log(this.tutorSchedule[i][j]);
if(this.tutorSchedule[i][j]==1){
this.colorsSched[i][j]='green';
}else{
this.colorsSched[i][j]='red';
} | console.log('payment form valid')
Stripe.card.createToken({
number: this.payment_form.value.cardNumber,
cvc: this.payment_form.value.cvc,
exp_month: this.payment_form.value.expiryMonth,
exp_year: this.payment_form.value.expiryYear
}, function(status, response) {
console.log(status);
console.log(response.error.message);
stripeToken = response.id;
Meteor.call('chargeCard', stripeToken, amount);
});
}
}
step1(): void{
this.checkout = false;
}
GoToCheckOut(): void{
// if(!this.user_skype_email){
// alert('Please enter your skype username so the teatch can contact you :)');
// }else{
// alert('you are now registered in this class :)');
// }
console.log(this.slot);
console.log(this.tutorSchedule)
this.tutorSchedule[this.day][this.slot]=2;
// Tutors.update(this.tutorId, {
// $set:{times: this.tutorSchedule }
// });
this.checkout=true;
}
onSubmit() {
let success= false;
let free= true;
if (this.payment_form_2.valid) {
this.submitted = true;
let m = this.payment_form_2.value.expDate[0]+this.payment_form_2.value.expDate[1];
let y = this.payment_form_2.value.expDate[5]+ | }
}
CheckoutFn():void{
if (this.payment_form.valid) { | random_line_split |
lib.go | pongWait = 60 * time.Second
// Send pings to client with this period. Must be less than pongWait.
pingPeriod = (pongWait * 9) / 10
// Time allowed to write the file to the client.
writeWait = 10 * time.Second
)
// Event types
const (
EVENT_CONNECT = iota
EVENT_ROAMING
EVENT_DISCONNECT
EVENT_LEVEL
)
type LeaseEntry struct {
IP string
MAC string
Server string
Hostname string
Comment string
}
type ReportEntry struct {
IP string
Name string
Interface string
SSID string
MAC string
Signal string
Hostname string
Comment string
}
type ReportEvent struct {
EventType int
Old ReportEntry
New ReportEntry
}
var WS = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
type BroadcastData struct {
Report []ReportEntry
ReportMap map[string]ReportEntry
Data string
LastUpdate time.Time
sync.RWMutex
ReportChan chan ReportEvent
}
type LeaseList struct {
List []LeaseEntry
sync.RWMutex
}
type ConfMikrotik struct {
Address string `yaml:"address"`
Username string `yaml:"username"`
Password string `yaml:"password"`
Interval time.Duration `yaml:"interval"`
Mode string `yaml:"mode"`
}
type ConfDevice struct {
Name string `yaml:"name"`
MAC string `yaml:"mac"`
OnConnect ConfigEvent `yaml:"on.connect"`
OnDisconnect ConfigEvent `yaml:"on.disconnect"`
OnRoaming ConfigEvent `yaml:"on.roaming"`
OnLevel ConfigEvent `yaml:"on.level"`
}
type ConfigEvent struct {
HttpPost string `yaml:"http.post"`
HttpGet string `yaml:"http.get"`
HttpPostContent string `yaml:"http.post.content"`
HttpHeader map[string]string `yaml:"http.header"`
}
type LogInfo struct {
Level log.Level `yaml:"level"`
}
type Config struct {
Log LogInfo `yaml:"log"`
Router ConfMikrotik `yaml:"router"`
DHCP ConfMikrotik `yaml:"dhcp"`
Devices []ConfDevice `yaml:"devices"`
}
// Init BroadcastData entry
func (b *BroadcastData) Init() {
b.ReportMap = map[string]ReportEntry{}
b.ReportChan = make(chan ReportEvent)
}
var broadcastData BroadcastData
var leaseList LeaseList
var config Config
var configMTX sync.RWMutex
var devList map[string]ConfDevice
var devListMTX sync.RWMutex
func GetDHCPLeases(address, username, password string) (list []LeaseEntry, err error) {
cl, err := routeros.Dial(address, username, password)
if err != nil {
return
}
defer cl.Close()
reply, err := cl.Run("/ip/dhcp-server/lease/print")
if err != nil {
return
}
for _, re := range reply.Re {
list = append(list, LeaseEntry{
IP: re.Map["address"],
MAC: re.Map["mac-address"],
Server: re.Map["server"],
Hostname: re.Map["host-name"],
Comment: re.Map["comment"],
})
}
return
}
func reloadDHCP() {
ticker := time.NewTicker(config.DHCP.Interval)
for { // nolint:gosimple
select {
case <-ticker.C:
l, err := GetDHCPLeases(config.DHCP.Address, config.DHCP.Username, config.DHCP.Password)
if err != nil {
log.WithFields(log.Fields{"dhcp-addr": config.DHCP.Address}).Error("Error reloading DHCP Leases: ", err)
return
} else {
leaseList.RLock()
leaseList.List = l
leaseList.RUnlock()
log.WithFields(log.Fields{"count": len(l)}).Debug("Reloaded DHCP Leases")
}
}
}
}
func FindLeaseByMAC(list []LeaseEntry, mac string) (e LeaseEntry, ok bool) {
for _, e := range list {
if e.MAC == mac {
return e, true
}
}
return
}
func RTLoop(c *routeros.Client, conf *Config) {
for {
cmd := "/caps-man/registration-table/print"
if strings.ToLower(config.Router.Mode) == "wifi" {
cmd = "/interface/wireless/registration-table/print"
}
reply, err := c.Run(cmd)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Error during request to CapsMan server: ", err)
// Try to close connection
c.Close()
// Reconnect loop
for {
// Sleep for 5 sec
time.Sleep(5 * time.Second)
cNew, err := routeros.Dial(config.Router.Address, config.Router.Username, config.Router.Password)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Reconnect error to CapsMan server: ", err)
continue
}
c = cNew
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Warn("Reconnected to CapsMan server")
break
}
continue
}
var report []ReportEntry
leaseList.RLock()
for _, re := range reply.Re {
var n, c, ip string
if le, ok := FindLeaseByMAC(leaseList.List, re.Map["mac-address"]); ok {
n = le.Hostname
c = le.Comment
ip = le.IP
}
devListMTX.RLock()
rec := ReportEntry{
IP: ip,
Name: devList[re.Map["mac-address"]].Name,
Interface: re.Map["interface"],
SSID: re.Map["ssid"],
MAC: re.Map["mac-address"],
Signal: re.Map["rx-signal"],
Hostname: n,
Comment: c,
}
if strings.ToLower(config.Router.Mode) == "wifi" {
rec.Signal = re.Map["signal-strength"]
if i := strings.Index(rec.Signal, "@"); i > 0 {
rec.Signal = rec.Signal[0:i]
}
}
devListMTX.RUnlock()
report = append(report, rec)
// fmt.Printf("%-20s\t%-20s\t%-20s\t%-10s\t%-30s\t%-30s\n", re.Map["interface"], re.Map["ssid"], re.Map["mac-address"], re.Map["rx-signal"], n, c)
}
log.WithFields(log.Fields{"count": len(report)}).Debug("Reloaded CapsMan entries")
leaseList.RUnlock()
if err = broadcastData.reportUpdate(report); err != nil {
log.WithFields(log.Fields{}).Warn("Error during reportUpdate: ", err)
}
time.Sleep(*interval)
}
}
func loadConfig(configFileName string) (config Config, err error) {
devListMTX.RLock()
defer devListMTX.RUnlock()
config = Config{}
devList = make(map[string]ConfDevice)
source, err := ioutil.ReadFile(configFileName)
if err != nil {
err = fmt.Errorf("cannot read config file [%s]", configFileName)
return
}
if err = yaml.Unmarshal(source, &config); err != nil {
err = fmt.Errorf("error parsing config file [%s]: %v", configFileName, err)
return
}
for _, v := range config.Devices {
devList[strings.ToUpper(v.MAC)] = v
}
return
}
func usage() {
}
// Handle report update request
func (b *BroadcastData) reportUpdate(report []ReportEntry) error {
output, err := json.Marshal(report)
if err != nil {
return err
}
// Lock mutex
b.RLock()
defer b.RUnlock()
// Prepare new list of entries
rm := map[string]ReportEntry{}
for _, v := range report {
rm[v.MAC] = v
}
// Scan for new entries
for k := range rm {
if _, ok := b.ReportMap[k]; !ok {
// New entry
b.ReportChan <- ReportEvent{
EventType: EVENT_CONNECT,
New: rm[k],
}
} else {
// Check for roaming
if rm[k].Interface != b.ReportMap[k].Interface {
b.ReportChan <- ReportEvent{
EventType: EVENT_ROAMING,
Old: b.ReportMap[k],
New: rm[k],
}
}
// Check for signal level change
if rm[k].Signal != b.ReportMap[k].Signal {
b.ReportChan <- ReportEvent{
EventType: EVENT_LEVEL,
Old: b.ReportMap[k],
New: rm[k],
| const (
// Time allowed to read the next pong message from the client. | random_line_split |
|
lib.go | .Time
sync.RWMutex
ReportChan chan ReportEvent
}
type LeaseList struct {
List []LeaseEntry
sync.RWMutex
}
type ConfMikrotik struct {
Address string `yaml:"address"`
Username string `yaml:"username"`
Password string `yaml:"password"`
Interval time.Duration `yaml:"interval"`
Mode string `yaml:"mode"`
}
type ConfDevice struct {
Name string `yaml:"name"`
MAC string `yaml:"mac"`
OnConnect ConfigEvent `yaml:"on.connect"`
OnDisconnect ConfigEvent `yaml:"on.disconnect"`
OnRoaming ConfigEvent `yaml:"on.roaming"`
OnLevel ConfigEvent `yaml:"on.level"`
}
type ConfigEvent struct {
HttpPost string `yaml:"http.post"`
HttpGet string `yaml:"http.get"`
HttpPostContent string `yaml:"http.post.content"`
HttpHeader map[string]string `yaml:"http.header"`
}
type LogInfo struct {
Level log.Level `yaml:"level"`
}
type Config struct {
Log LogInfo `yaml:"log"`
Router ConfMikrotik `yaml:"router"`
DHCP ConfMikrotik `yaml:"dhcp"`
Devices []ConfDevice `yaml:"devices"`
}
// Init BroadcastData entry
func (b *BroadcastData) Init() {
b.ReportMap = map[string]ReportEntry{}
b.ReportChan = make(chan ReportEvent)
}
var broadcastData BroadcastData
var leaseList LeaseList
var config Config
var configMTX sync.RWMutex
var devList map[string]ConfDevice
var devListMTX sync.RWMutex
func GetDHCPLeases(address, username, password string) (list []LeaseEntry, err error) {
cl, err := routeros.Dial(address, username, password)
if err != nil {
return
}
defer cl.Close()
reply, err := cl.Run("/ip/dhcp-server/lease/print")
if err != nil {
return
}
for _, re := range reply.Re {
list = append(list, LeaseEntry{
IP: re.Map["address"],
MAC: re.Map["mac-address"],
Server: re.Map["server"],
Hostname: re.Map["host-name"],
Comment: re.Map["comment"],
})
}
return
}
func reloadDHCP() |
func FindLeaseByMAC(list []LeaseEntry, mac string) (e LeaseEntry, ok bool) {
for _, e := range list {
if e.MAC == mac {
return e, true
}
}
return
}
func RTLoop(c *routeros.Client, conf *Config) {
for {
cmd := "/caps-man/registration-table/print"
if strings.ToLower(config.Router.Mode) == "wifi" {
cmd = "/interface/wireless/registration-table/print"
}
reply, err := c.Run(cmd)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Error during request to CapsMan server: ", err)
// Try to close connection
c.Close()
// Reconnect loop
for {
// Sleep for 5 sec
time.Sleep(5 * time.Second)
cNew, err := routeros.Dial(config.Router.Address, config.Router.Username, config.Router.Password)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Reconnect error to CapsMan server: ", err)
continue
}
c = cNew
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Warn("Reconnected to CapsMan server")
break
}
continue
}
var report []ReportEntry
leaseList.RLock()
for _, re := range reply.Re {
var n, c, ip string
if le, ok := FindLeaseByMAC(leaseList.List, re.Map["mac-address"]); ok {
n = le.Hostname
c = le.Comment
ip = le.IP
}
devListMTX.RLock()
rec := ReportEntry{
IP: ip,
Name: devList[re.Map["mac-address"]].Name,
Interface: re.Map["interface"],
SSID: re.Map["ssid"],
MAC: re.Map["mac-address"],
Signal: re.Map["rx-signal"],
Hostname: n,
Comment: c,
}
if strings.ToLower(config.Router.Mode) == "wifi" {
rec.Signal = re.Map["signal-strength"]
if i := strings.Index(rec.Signal, "@"); i > 0 {
rec.Signal = rec.Signal[0:i]
}
}
devListMTX.RUnlock()
report = append(report, rec)
// fmt.Printf("%-20s\t%-20s\t%-20s\t%-10s\t%-30s\t%-30s\n", re.Map["interface"], re.Map["ssid"], re.Map["mac-address"], re.Map["rx-signal"], n, c)
}
log.WithFields(log.Fields{"count": len(report)}).Debug("Reloaded CapsMan entries")
leaseList.RUnlock()
if err = broadcastData.reportUpdate(report); err != nil {
log.WithFields(log.Fields{}).Warn("Error during reportUpdate: ", err)
}
time.Sleep(*interval)
}
}
func loadConfig(configFileName string) (config Config, err error) {
devListMTX.RLock()
defer devListMTX.RUnlock()
config = Config{}
devList = make(map[string]ConfDevice)
source, err := ioutil.ReadFile(configFileName)
if err != nil {
err = fmt.Errorf("cannot read config file [%s]", configFileName)
return
}
if err = yaml.Unmarshal(source, &config); err != nil {
err = fmt.Errorf("error parsing config file [%s]: %v", configFileName, err)
return
}
for _, v := range config.Devices {
devList[strings.ToUpper(v.MAC)] = v
}
return
}
func usage() {
}
// Handle report update request
func (b *BroadcastData) reportUpdate(report []ReportEntry) error {
output, err := json.Marshal(report)
if err != nil {
return err
}
// Lock mutex
b.RLock()
defer b.RUnlock()
// Prepare new list of entries
rm := map[string]ReportEntry{}
for _, v := range report {
rm[v.MAC] = v
}
// Scan for new entries
for k := range rm {
if _, ok := b.ReportMap[k]; !ok {
// New entry
b.ReportChan <- ReportEvent{
EventType: EVENT_CONNECT,
New: rm[k],
}
} else {
// Check for roaming
if rm[k].Interface != b.ReportMap[k].Interface {
b.ReportChan <- ReportEvent{
EventType: EVENT_ROAMING,
Old: b.ReportMap[k],
New: rm[k],
}
}
// Check for signal level change
if rm[k].Signal != b.ReportMap[k].Signal {
b.ReportChan <- ReportEvent{
EventType: EVENT_LEVEL,
Old: b.ReportMap[k],
New: rm[k],
}
}
}
}
// Scan for deleted entries
for k := range b.ReportMap {
if _, ok := rm[k]; !ok {
b.ReportChan <- ReportEvent{
EventType: EVENT_DISCONNECT,
Old: b.ReportMap[k],
}
}
}
b.ReportMap = rm
b.Report = report
b.Data = string(output)
b.LastUpdate = time.Now()
return nil
}
func (b *BroadcastData) EventHandler() {
for { // nolint:gosimple
select {
case data := <-b.ReportChan:
// fmt.Printf("New event received: %v\n", data)
switch data.EventType {
case EVENT_CONNECT:
log.WithFields(log.Fields{"action": "register", "mac": data.New.MAC, "name": data.New.Name, "interface": data.New.Interface, "ssid": data.New.SSID, "hostname": data.New.Hostname, "comment": data.New.Comment, "level-to": data.New.Signal}).Info("New connection registered")
// Get device info
devListMTX.RLock()
dev, ok := devList[data.New.MAC]
devListMTX.RUnlock()
| {
ticker := time.NewTicker(config.DHCP.Interval)
for { // nolint:gosimple
select {
case <-ticker.C:
l, err := GetDHCPLeases(config.DHCP.Address, config.DHCP.Username, config.DHCP.Password)
if err != nil {
log.WithFields(log.Fields{"dhcp-addr": config.DHCP.Address}).Error("Error reloading DHCP Leases: ", err)
return
} else {
leaseList.RLock()
leaseList.List = l
leaseList.RUnlock()
log.WithFields(log.Fields{"count": len(l)}).Debug("Reloaded DHCP Leases")
}
}
}
} | identifier_body |
lib.go | time.Time
sync.RWMutex
ReportChan chan ReportEvent
}
type LeaseList struct {
List []LeaseEntry
sync.RWMutex
}
type ConfMikrotik struct {
Address string `yaml:"address"`
Username string `yaml:"username"`
Password string `yaml:"password"`
Interval time.Duration `yaml:"interval"`
Mode string `yaml:"mode"`
}
type ConfDevice struct {
Name string `yaml:"name"`
MAC string `yaml:"mac"`
OnConnect ConfigEvent `yaml:"on.connect"`
OnDisconnect ConfigEvent `yaml:"on.disconnect"`
OnRoaming ConfigEvent `yaml:"on.roaming"`
OnLevel ConfigEvent `yaml:"on.level"`
}
type ConfigEvent struct {
HttpPost string `yaml:"http.post"`
HttpGet string `yaml:"http.get"`
HttpPostContent string `yaml:"http.post.content"`
HttpHeader map[string]string `yaml:"http.header"`
}
type LogInfo struct {
Level log.Level `yaml:"level"`
}
type Config struct {
Log LogInfo `yaml:"log"`
Router ConfMikrotik `yaml:"router"`
DHCP ConfMikrotik `yaml:"dhcp"`
Devices []ConfDevice `yaml:"devices"`
}
// Init BroadcastData entry
func (b *BroadcastData) Init() {
b.ReportMap = map[string]ReportEntry{}
b.ReportChan = make(chan ReportEvent)
}
var broadcastData BroadcastData
var leaseList LeaseList
var config Config
var configMTX sync.RWMutex
var devList map[string]ConfDevice
var devListMTX sync.RWMutex
func GetDHCPLeases(address, username, password string) (list []LeaseEntry, err error) {
cl, err := routeros.Dial(address, username, password)
if err != nil {
return
}
defer cl.Close()
reply, err := cl.Run("/ip/dhcp-server/lease/print")
if err != nil {
return
}
for _, re := range reply.Re {
list = append(list, LeaseEntry{
IP: re.Map["address"],
MAC: re.Map["mac-address"],
Server: re.Map["server"],
Hostname: re.Map["host-name"],
Comment: re.Map["comment"],
})
}
return
}
func reloadDHCP() {
ticker := time.NewTicker(config.DHCP.Interval)
for { // nolint:gosimple
select {
case <-ticker.C:
l, err := GetDHCPLeases(config.DHCP.Address, config.DHCP.Username, config.DHCP.Password)
if err != nil {
log.WithFields(log.Fields{"dhcp-addr": config.DHCP.Address}).Error("Error reloading DHCP Leases: ", err)
return
} else {
leaseList.RLock()
leaseList.List = l
leaseList.RUnlock()
log.WithFields(log.Fields{"count": len(l)}).Debug("Reloaded DHCP Leases")
}
}
}
}
func FindLeaseByMAC(list []LeaseEntry, mac string) (e LeaseEntry, ok bool) {
for _, e := range list {
if e.MAC == mac {
return e, true
}
}
return
}
func RTLoop(c *routeros.Client, conf *Config) {
for {
cmd := "/caps-man/registration-table/print"
if strings.ToLower(config.Router.Mode) == "wifi" {
cmd = "/interface/wireless/registration-table/print"
}
reply, err := c.Run(cmd)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Error during request to CapsMan server: ", err)
// Try to close connection
c.Close()
// Reconnect loop
for {
// Sleep for 5 sec
time.Sleep(5 * time.Second)
cNew, err := routeros.Dial(config.Router.Address, config.Router.Username, config.Router.Password)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Reconnect error to CapsMan server: ", err)
continue
}
c = cNew
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Warn("Reconnected to CapsMan server")
break
}
continue
}
var report []ReportEntry
leaseList.RLock()
for _, re := range reply.Re {
var n, c, ip string
if le, ok := FindLeaseByMAC(leaseList.List, re.Map["mac-address"]); ok {
n = le.Hostname
c = le.Comment
ip = le.IP
}
devListMTX.RLock()
rec := ReportEntry{
IP: ip,
Name: devList[re.Map["mac-address"]].Name,
Interface: re.Map["interface"],
SSID: re.Map["ssid"],
MAC: re.Map["mac-address"],
Signal: re.Map["rx-signal"],
Hostname: n,
Comment: c,
}
if strings.ToLower(config.Router.Mode) == "wifi" {
rec.Signal = re.Map["signal-strength"]
if i := strings.Index(rec.Signal, "@"); i > 0 {
rec.Signal = rec.Signal[0:i]
}
}
devListMTX.RUnlock()
report = append(report, rec)
// fmt.Printf("%-20s\t%-20s\t%-20s\t%-10s\t%-30s\t%-30s\n", re.Map["interface"], re.Map["ssid"], re.Map["mac-address"], re.Map["rx-signal"], n, c)
}
log.WithFields(log.Fields{"count": len(report)}).Debug("Reloaded CapsMan entries")
leaseList.RUnlock()
if err = broadcastData.reportUpdate(report); err != nil {
log.WithFields(log.Fields{}).Warn("Error during reportUpdate: ", err)
}
time.Sleep(*interval)
}
}
func loadConfig(configFileName string) (config Config, err error) {
devListMTX.RLock()
defer devListMTX.RUnlock()
config = Config{}
devList = make(map[string]ConfDevice)
source, err := ioutil.ReadFile(configFileName)
if err != nil {
err = fmt.Errorf("cannot read config file [%s]", configFileName)
return
}
if err = yaml.Unmarshal(source, &config); err != nil {
err = fmt.Errorf("error parsing config file [%s]: %v", configFileName, err)
return
}
for _, v := range config.Devices {
devList[strings.ToUpper(v.MAC)] = v
}
return
}
func | () {
}
// Handle report update request
func (b *BroadcastData) reportUpdate(report []ReportEntry) error {
output, err := json.Marshal(report)
if err != nil {
return err
}
// Lock mutex
b.RLock()
defer b.RUnlock()
// Prepare new list of entries
rm := map[string]ReportEntry{}
for _, v := range report {
rm[v.MAC] = v
}
// Scan for new entries
for k := range rm {
if _, ok := b.ReportMap[k]; !ok {
// New entry
b.ReportChan <- ReportEvent{
EventType: EVENT_CONNECT,
New: rm[k],
}
} else {
// Check for roaming
if rm[k].Interface != b.ReportMap[k].Interface {
b.ReportChan <- ReportEvent{
EventType: EVENT_ROAMING,
Old: b.ReportMap[k],
New: rm[k],
}
}
// Check for signal level change
if rm[k].Signal != b.ReportMap[k].Signal {
b.ReportChan <- ReportEvent{
EventType: EVENT_LEVEL,
Old: b.ReportMap[k],
New: rm[k],
}
}
}
}
// Scan for deleted entries
for k := range b.ReportMap {
if _, ok := rm[k]; !ok {
b.ReportChan <- ReportEvent{
EventType: EVENT_DISCONNECT,
Old: b.ReportMap[k],
}
}
}
b.ReportMap = rm
b.Report = report
b.Data = string(output)
b.LastUpdate = time.Now()
return nil
}
func (b *BroadcastData) EventHandler() {
for { // nolint:gosimple
select {
case data := <-b.ReportChan:
// fmt.Printf("New event received: %v\n", data)
switch data.EventType {
case EVENT_CONNECT:
log.WithFields(log.Fields{"action": "register", "mac": data.New.MAC, "name": data.New.Name, "interface": data.New.Interface, "ssid": data.New.SSID, "hostname": data.New.Hostname, "comment": data.New.Comment, "level-to": data.New.Signal}).Info("New connection registered")
// Get device info
devListMTX.RLock()
dev, ok := devList[data.New.MAC]
devListMTX.RUnlock()
| usage | identifier_name |
lib.go | "wifi" {
cmd = "/interface/wireless/registration-table/print"
}
reply, err := c.Run(cmd)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Error during request to CapsMan server: ", err)
// Try to close connection
c.Close()
// Reconnect loop
for {
// Sleep for 5 sec
time.Sleep(5 * time.Second)
cNew, err := routeros.Dial(config.Router.Address, config.Router.Username, config.Router.Password)
if err != nil {
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Error("Reconnect error to CapsMan server: ", err)
continue
}
c = cNew
log.WithFields(log.Fields{"address": config.Router.Address, "username": config.Router.Username}).Warn("Reconnected to CapsMan server")
break
}
continue
}
var report []ReportEntry
leaseList.RLock()
for _, re := range reply.Re {
var n, c, ip string
if le, ok := FindLeaseByMAC(leaseList.List, re.Map["mac-address"]); ok {
n = le.Hostname
c = le.Comment
ip = le.IP
}
devListMTX.RLock()
rec := ReportEntry{
IP: ip,
Name: devList[re.Map["mac-address"]].Name,
Interface: re.Map["interface"],
SSID: re.Map["ssid"],
MAC: re.Map["mac-address"],
Signal: re.Map["rx-signal"],
Hostname: n,
Comment: c,
}
if strings.ToLower(config.Router.Mode) == "wifi" {
rec.Signal = re.Map["signal-strength"]
if i := strings.Index(rec.Signal, "@"); i > 0 {
rec.Signal = rec.Signal[0:i]
}
}
devListMTX.RUnlock()
report = append(report, rec)
// fmt.Printf("%-20s\t%-20s\t%-20s\t%-10s\t%-30s\t%-30s\n", re.Map["interface"], re.Map["ssid"], re.Map["mac-address"], re.Map["rx-signal"], n, c)
}
log.WithFields(log.Fields{"count": len(report)}).Debug("Reloaded CapsMan entries")
leaseList.RUnlock()
if err = broadcastData.reportUpdate(report); err != nil {
log.WithFields(log.Fields{}).Warn("Error during reportUpdate: ", err)
}
time.Sleep(*interval)
}
}
func loadConfig(configFileName string) (config Config, err error) {
devListMTX.RLock()
defer devListMTX.RUnlock()
config = Config{}
devList = make(map[string]ConfDevice)
source, err := ioutil.ReadFile(configFileName)
if err != nil {
err = fmt.Errorf("cannot read config file [%s]", configFileName)
return
}
if err = yaml.Unmarshal(source, &config); err != nil {
err = fmt.Errorf("error parsing config file [%s]: %v", configFileName, err)
return
}
for _, v := range config.Devices {
devList[strings.ToUpper(v.MAC)] = v
}
return
}
func usage() {
}
// Handle report update request
func (b *BroadcastData) reportUpdate(report []ReportEntry) error {
output, err := json.Marshal(report)
if err != nil {
return err
}
// Lock mutex
b.RLock()
defer b.RUnlock()
// Prepare new list of entries
rm := map[string]ReportEntry{}
for _, v := range report {
rm[v.MAC] = v
}
// Scan for new entries
for k := range rm {
if _, ok := b.ReportMap[k]; !ok {
// New entry
b.ReportChan <- ReportEvent{
EventType: EVENT_CONNECT,
New: rm[k],
}
} else {
// Check for roaming
if rm[k].Interface != b.ReportMap[k].Interface {
b.ReportChan <- ReportEvent{
EventType: EVENT_ROAMING,
Old: b.ReportMap[k],
New: rm[k],
}
}
// Check for signal level change
if rm[k].Signal != b.ReportMap[k].Signal {
b.ReportChan <- ReportEvent{
EventType: EVENT_LEVEL,
Old: b.ReportMap[k],
New: rm[k],
}
}
}
}
// Scan for deleted entries
for k := range b.ReportMap {
if _, ok := rm[k]; !ok {
b.ReportChan <- ReportEvent{
EventType: EVENT_DISCONNECT,
Old: b.ReportMap[k],
}
}
}
b.ReportMap = rm
b.Report = report
b.Data = string(output)
b.LastUpdate = time.Now()
return nil
}
func (b *BroadcastData) EventHandler() {
for { // nolint:gosimple
select {
case data := <-b.ReportChan:
// fmt.Printf("New event received: %v\n", data)
switch data.EventType {
case EVENT_CONNECT:
log.WithFields(log.Fields{"action": "register", "mac": data.New.MAC, "name": data.New.Name, "interface": data.New.Interface, "ssid": data.New.SSID, "hostname": data.New.Hostname, "comment": data.New.Comment, "level-to": data.New.Signal}).Info("New connection registered")
// Get device info
devListMTX.RLock()
dev, ok := devList[data.New.MAC]
devListMTX.RUnlock()
if ok {
if (len(dev.OnConnect.HttpPost) > 0) || (len(dev.OnConnect.HttpGet) > 0) {
go makeRequest(dev.OnConnect, map[string]string{
"name": dev.Name,
"mac": data.New.MAC,
"roaming.to": "",
"roaming.from": "",
"level.to": data.New.Signal,
"level.from": "",
})
}
}
case EVENT_DISCONNECT:
log.WithFields(log.Fields{"action": "disconnect", "mac": data.Old.MAC, "name": data.Old.Name, "interface": data.Old.Interface, "hostname": data.Old.Hostname, "comment": data.Old.Comment}).Info("Client disconnect")
// Get device info
devListMTX.RLock()
dev, ok := devList[data.New.MAC]
devListMTX.RUnlock()
if ok {
if (len(dev.OnDisconnect.HttpPost) > 0) || (len(dev.OnDisconnect.HttpGet) > 0) {
go makeRequest(dev.OnDisconnect, map[string]string{
"name": dev.Name,
"mac": data.Old.MAC,
"roaming.to": "",
"roaming.from": "",
"level.to": "",
"level.from": data.Old.Signal,
})
}
}
case EVENT_ROAMING:
log.WithFields(log.Fields{"action": "roaming", "mac": data.New.MAC, "name": data.New.Name, "interface-from": data.Old.Interface, "interface-to": data.New.Interface, "level-from": data.Old.Signal, "level-to": data.New.Signal}).Info("Client roaming")
// Get device info
devListMTX.RLock()
dev, ok := devList[data.New.MAC]
devListMTX.RUnlock()
if ok {
if (len(dev.OnRoaming.HttpPost) > 0) || (len(dev.OnRoaming.HttpGet) > 0) {
go makeRequest(dev.OnRoaming, map[string]string{
"name": dev.Name,
"mac": data.New.MAC,
"roaming.to": data.New.Interface,
"roaming.from": data.Old.Interface,
"level.from": data.Old.Signal,
"level.to": data.New.Signal,
})
}
}
case EVENT_LEVEL:
log.WithFields(log.Fields{"action": "level", "mac": data.New.MAC, "name": data.New.Name, "interface": data.New.Interface, "level-from": data.Old.Signal, "level-to": data.New.Signal}).Debug("Signal level change")
// Get device info
devListMTX.RLock()
dev, ok := devList[data.New.MAC]
devListMTX.RUnlock()
if ok | {
if (len(dev.OnLevel.HttpPost) > 0) || (len(dev.OnLevel.HttpGet) > 0) {
go makeRequest(dev.OnLevel, map[string]string{
"name": dev.Name,
"mac": data.Old.MAC,
"roaming.to": "",
"roaming.from": "",
"level.from": data.Old.Signal,
"level.to": data.New.Signal,
})
}
} | conditional_block |
|
uiTools.js | allPossibleKesmNames', function() {
return KesmNames.find().map(function(doc) { return doc.kesmName; });
});
});
getAllDataForKesmName = function(kesmName) {
var properties = {};
if (propertyCollections && _.has(propertyCollections, kesmName)) {
_.each(propertyCollections[kesmName].find().fetch(), function(doc) {
properties[doc.property] = doc.value;
});
}
var sample = Samples.findOne(properties['currentSampleID']) || null;
var machine = Machines.findOne({ kesmName: kesmName });
var process;
if (!! machine) {
process = Processes.findOne({
className: { $in: ['KESMMain', 'KESM'] },
machineId: machine._id
});
} else {
machine = null;
process = null;
}
var uri = "http://" + Meteor.settings.public.serverURIs[kesmName];
return {
kesmName: kesmName,
machine: machine,
process: process,
properties: properties,
sample: sample,
uri: uri
};
};
Template.registerHelper('allDataForKesmName', getAllDataForKesmName);
Template.registerHelper('odd', function(value) {
return (value % 2 !== 0);
});
Template.registerHelper('classForDot', function(active) {
return active? 'green' : 'red';
});
toTitleCase = function(str) {
return str.replace(/\w\S*/g, function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
});
};
// Small Collection of utility functions to make the gui-widgits dance etc.
AxisList = [{
axis: 'x',
AXIS: 'X',
index: 0
}, {
axis: 'y',
AXIS: 'Y',
index: 1
}, {
axis: 'z',
AXIS: 'Z',
index: 2
}];
Template.registerHelper('axes', function() {
return AxisList;
});
axisIndex = function(axisLetter) {
return _.findWhere(AxisList, { axis: axisLetter.toLowerCase() }).index;
};
var axisIsInFault = function(axis) {
return getPropValue('stage_'+axis+'_fault', false);
};
Template.registerHelper('colorClassForAxis', function(axisLetter) {
var colorForAxis = {
x: 'error',
y: 'success',
z: 'info',
};
if (axisIsInFault(axisLetter)) {
return 'fault';
} else {
return colorForAxis[axisLetter];
}
});
Template.registerHelper('isInFault', axisIsInFault);
var scopeModes = [{
mode: 'maintenance'
}, {
mode: 'focus'
}, {
mode: 'slicing'
}];
Template.registerHelper('scopeModes', function() {
return scopeModes;
});
Template.registerHelper('scopeIsInMode', function(mode) {
var scopeMode = getPropValue('scopeMode', 'maintenance');
return scopeMode.value === mode;
});
Template.registerHelper('changingModes', function() {
var scopeMode = getPropValue('scopeMode', 'maintenance');
return scopeMode.value !== scopeMode.requestedValue;
});
firmlyInSlicingMode = function() {
var scopeMode = getProperty('scopeMode', 'maintenance');
return (scopeMode.value === 'slicing') && (scopeMode.value === scopeMode.requestedValue);
};
slicingOrChanging = function() {
var scopeMode = getProperty('scopeMode', 'maintenance');
return (scopeMode.value === 'slicing') || scopeMode.value !== scopeMode.requestedValue;
};
Template.registerHelper('slicingOrChanging', slicingOrChanging);
// Returns 'disabled' if the scope is in 'slicing' mode, or if it's changing modes.
// This is used to disable buttons and inputs.
disabledIfSlicingOrChanging = function() {
return slicingOrChanging()? 'disabled' : '';
};
Template.registerHelper('disabledIfSlicingOrChanging', disabledIfSlicingOrChanging);
Template.registerHelper('disabledUnlessSlicing', function() {
return firmlyInSlicingMode()? '' : 'disabled';
});
// The default number of digits to display for floating point numbers.
// If this is 0, then num.toFixed(0) should round to the nearest integer.
var NUM_DECIMALS = 1;
roundIfNumber = function(value, numDecimals) {
if (_.isUndefined(numDecimals)) {
numDecimals = NUM_DECIMALS;
}
return _.isNumber(value)? value.toFixed(numDecimals) : value;
};
getRoundedProp = function(propName, defaultValue, numDecimals) {
var value = getPropValue(propName, defaultValue);
// Don't try to round the default value, since it could already be a string.
if (value === defaultValue) {
return value;
}
return roundIfNumber(value, numDecimals);
};
Template.registerHelper('getRoundedProp', getRoundedProp);
// This is a bit of a hack to make it easier to use a template
// like a controller object. Use it like:
// {{#with data a=true b=1}} | Template.registerHelper('data', function(data) {
return data.hash;
});
Meteor.cb = function(e,r) {
if (e) console.error(e);
if(r) {
if (_.isArray(r) && console.table) {
console.table(r);
} else {
console.log(r);
}
}
};
guiUtils = {};
guiUtils.makeMeteorReactiveTextBox = function(textInputQuery, meteorPropertyName, options) {
options = options || {};
var cleanseFunction = options.cleanseFunction || parseFloat;
var updateFunction = options.updateFunction || 'updateProperty';
var interacting = false;
var propertySelector = {
property: meteorPropertyName
}; // Meteor Property selector
// Meteor -> jQuery-ui
var updateTextBoxFromMeteor = function() {
// Query the relevent stage data source
var tbQuery = Properties.findOne(propertySelector);
// Do not update if user interaction is going on
// Update the text box if the mongo property has changed
if (interacting) {
return;
}
if (tbQuery) {
$(textInputQuery).val(tbQuery.value);
}
};
// Call this first when the slider is initialized, and when changes happen
Tracker.autorun(updateTextBoxFromMeteor);
// jQuery-ui -> Meteor
var pushTextChangeToMeteor = function() {
var currentValue = $(textInputQuery).val();
if (cleanseFunction) {
currentValue = cleanseFunction(currentValue);
}
Meteor.call(updateFunction, meteorPropertyName, currentValue, options, Meteor.cb);
// Also change it back to the parsed version
$(textInputQuery).val(currentValue);
};
// Now we register change handlers via the various jQuery whatnot
// Register doing an update on a enter key
$(textInputQuery).bind('keypress', function(event) {
var code = (event.keyCode ? event.keyCode : event.which);
//Enter keycode
if (code == 13) {
// Force focus-out
$(textInputQuery).blur();
}
});
// Make a change commit if the field loses focus
$(textInputQuery).focusout(function(event) {
pushTextChangeToMeteor();
interacting = false;
});
// Disable updating when user is editing values
$(textInputQuery).focusin(function(event) {
interacting = true;
});
};
// Functions to init sliders on gui, also registers Meteor Tracker
guiUtils.makeMeteorPropSlider = function(searchId, meteorPropertyName, cleanFunc, updateMethodName) {
// Flag for is the slider is being used
var interacting = false;
// Select and create the slider element
// Also register the start and stip functions
$(searchId).slider({
range: "min",
step: 0.000001,
min: 0.0,
max: 60.0,
start: function(event, ui) {
interacting = true;
},
stop: function(event, ui) {
var sliderLocation = $(searchId).slider("value");
// Update the metor when the slider is dropped somewhere new
Meteor.call(updateMethodName, meteorPropertyName, cleanFunc(sliderLocation), "web");
interacting = false;
}
});
// Closured function to update the slider defined based on meteor values
Tracker.autorun(function() {
// Query the relevent stage data source
var valueQuery = Properties.findOne({
property: meteorPropertyName
});
if (valueQuery && !interacting) {
// Update the fucking slider
$(searchId).slider("value", valueQuery.value);
}
});
};
// Initialize the image-extents slider (diff b/c it has two sliders)
guiUtils.initImageExtentSlider = function(axisName) {
var interacting = false;
// name for the jQuery selector
var sliderName = "#image" + axisName + "AreaSlider";
// Meteor property names
var propertyNameMin = "slice_" + axisName + "_min";
var propertyNameMax = "slice_" + axisName + "_max";
// Init the slider with default values . . .
// The values will later be updated by autorun function | // {{> controllerTemplate}}
// {{/with}} | random_line_split |
uiTools.js | PossibleKesmNames', function() {
return KesmNames.find().map(function(doc) { return doc.kesmName; });
});
});
getAllDataForKesmName = function(kesmName) {
var properties = {};
if (propertyCollections && _.has(propertyCollections, kesmName)) {
_.each(propertyCollections[kesmName].find().fetch(), function(doc) {
properties[doc.property] = doc.value;
});
}
var sample = Samples.findOne(properties['currentSampleID']) || null;
var machine = Machines.findOne({ kesmName: kesmName });
var process;
if (!! machine) {
process = Processes.findOne({
className: { $in: ['KESMMain', 'KESM'] },
machineId: machine._id
});
} else {
machine = null;
process = null;
}
var uri = "http://" + Meteor.settings.public.serverURIs[kesmName];
return {
kesmName: kesmName,
machine: machine,
process: process,
properties: properties,
sample: sample,
uri: uri
};
};
Template.registerHelper('allDataForKesmName', getAllDataForKesmName);
Template.registerHelper('odd', function(value) {
return (value % 2 !== 0);
});
Template.registerHelper('classForDot', function(active) {
return active? 'green' : 'red';
});
toTitleCase = function(str) {
return str.replace(/\w\S*/g, function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
});
};
// Small Collection of utility functions to make the gui-widgits dance etc.
AxisList = [{
axis: 'x',
AXIS: 'X',
index: 0
}, {
axis: 'y',
AXIS: 'Y',
index: 1
}, {
axis: 'z',
AXIS: 'Z',
index: 2
}];
Template.registerHelper('axes', function() {
return AxisList;
});
axisIndex = function(axisLetter) {
return _.findWhere(AxisList, { axis: axisLetter.toLowerCase() }).index;
};
var axisIsInFault = function(axis) {
return getPropValue('stage_'+axis+'_fault', false);
};
Template.registerHelper('colorClassForAxis', function(axisLetter) {
var colorForAxis = {
x: 'error',
y: 'success',
z: 'info',
};
if (axisIsInFault(axisLetter)) {
return 'fault';
} else {
return colorForAxis[axisLetter];
}
});
Template.registerHelper('isInFault', axisIsInFault);
var scopeModes = [{
mode: 'maintenance'
}, {
mode: 'focus'
}, {
mode: 'slicing'
}];
Template.registerHelper('scopeModes', function() {
return scopeModes;
});
Template.registerHelper('scopeIsInMode', function(mode) {
var scopeMode = getPropValue('scopeMode', 'maintenance');
return scopeMode.value === mode;
});
Template.registerHelper('changingModes', function() {
var scopeMode = getPropValue('scopeMode', 'maintenance');
return scopeMode.value !== scopeMode.requestedValue;
});
firmlyInSlicingMode = function() {
var scopeMode = getProperty('scopeMode', 'maintenance');
return (scopeMode.value === 'slicing') && (scopeMode.value === scopeMode.requestedValue);
};
slicingOrChanging = function() {
var scopeMode = getProperty('scopeMode', 'maintenance');
return (scopeMode.value === 'slicing') || scopeMode.value !== scopeMode.requestedValue;
};
Template.registerHelper('slicingOrChanging', slicingOrChanging);
// Returns 'disabled' if the scope is in 'slicing' mode, or if it's changing modes.
// This is used to disable buttons and inputs.
disabledIfSlicingOrChanging = function() {
return slicingOrChanging()? 'disabled' : '';
};
Template.registerHelper('disabledIfSlicingOrChanging', disabledIfSlicingOrChanging);
Template.registerHelper('disabledUnlessSlicing', function() {
return firmlyInSlicingMode()? '' : 'disabled';
});
// The default number of digits to display for floating point numbers.
// If this is 0, then num.toFixed(0) should round to the nearest integer.
var NUM_DECIMALS = 1;
roundIfNumber = function(value, numDecimals) {
if (_.isUndefined(numDecimals)) {
numDecimals = NUM_DECIMALS;
}
return _.isNumber(value)? value.toFixed(numDecimals) : value;
};
getRoundedProp = function(propName, defaultValue, numDecimals) {
var value = getPropValue(propName, defaultValue);
// Don't try to round the default value, since it could already be a string.
if (value === defaultValue) {
return value;
}
return roundIfNumber(value, numDecimals);
};
Template.registerHelper('getRoundedProp', getRoundedProp);
// This is a bit of a hack to make it easier to use a template
// like a controller object. Use it like:
// {{#with data a=true b=1}}
// {{> controllerTemplate}}
// {{/with}}
Template.registerHelper('data', function(data) {
return data.hash;
});
Meteor.cb = function(e,r) {
if (e) console.error(e);
if(r) {
if (_.isArray(r) && console.table) {
console.table(r);
} else {
console.log(r);
}
}
};
guiUtils = {};
guiUtils.makeMeteorReactiveTextBox = function(textInputQuery, meteorPropertyName, options) {
options = options || {};
var cleanseFunction = options.cleanseFunction || parseFloat;
var updateFunction = options.updateFunction || 'updateProperty';
var interacting = false;
var propertySelector = {
property: meteorPropertyName
}; // Meteor Property selector
// Meteor -> jQuery-ui
var updateTextBoxFromMeteor = function() {
// Query the relevent stage data source
var tbQuery = Properties.findOne(propertySelector);
// Do not update if user interaction is going on
// Update the text box if the mongo property has changed
if (interacting) |
if (tbQuery) {
$(textInputQuery).val(tbQuery.value);
}
};
// Call this first when the slider is initialized, and when changes happen
Tracker.autorun(updateTextBoxFromMeteor);
// jQuery-ui -> Meteor
var pushTextChangeToMeteor = function() {
var currentValue = $(textInputQuery).val();
if (cleanseFunction) {
currentValue = cleanseFunction(currentValue);
}
Meteor.call(updateFunction, meteorPropertyName, currentValue, options, Meteor.cb);
// Also change it back to the parsed version
$(textInputQuery).val(currentValue);
};
// Now we register change handlers via the various jQuery whatnot
// Register doing an update on a enter key
$(textInputQuery).bind('keypress', function(event) {
var code = (event.keyCode ? event.keyCode : event.which);
//Enter keycode
if (code == 13) {
// Force focus-out
$(textInputQuery).blur();
}
});
// Make a change commit if the field loses focus
$(textInputQuery).focusout(function(event) {
pushTextChangeToMeteor();
interacting = false;
});
// Disable updating when user is editing values
$(textInputQuery).focusin(function(event) {
interacting = true;
});
};
// Functions to init sliders on gui, also registers Meteor Tracker
guiUtils.makeMeteorPropSlider = function(searchId, meteorPropertyName, cleanFunc, updateMethodName) {
// Flag for is the slider is being used
var interacting = false;
// Select and create the slider element
// Also register the start and stip functions
$(searchId).slider({
range: "min",
step: 0.000001,
min: 0.0,
max: 60.0,
start: function(event, ui) {
interacting = true;
},
stop: function(event, ui) {
var sliderLocation = $(searchId).slider("value");
// Update the metor when the slider is dropped somewhere new
Meteor.call(updateMethodName, meteorPropertyName, cleanFunc(sliderLocation), "web");
interacting = false;
}
});
// Closured function to update the slider defined based on meteor values
Tracker.autorun(function() {
// Query the relevent stage data source
var valueQuery = Properties.findOne({
property: meteorPropertyName
});
if (valueQuery && !interacting) {
// Update the fucking slider
$(searchId).slider("value", valueQuery.value);
}
});
};
// Initialize the image-extents slider (diff b/c it has two sliders)
guiUtils.initImageExtentSlider = function(axisName) {
var interacting = false;
// name for the jQuery selector
var sliderName = "#image" + axisName + "AreaSlider";
// Meteor property names
var propertyNameMin = "slice_" + axisName + "_min";
var propertyNameMax = "slice_" + axisName + "_max";
// Init the slider with default values . . .
// The values will later be updated by autorun | {
return;
} | conditional_block |
BatteryMonitor6813Tester.go | TC6813.New(spiConnection, 2).Initialise()
//
// }
ltc_lock.Lock()
defer ltc_lock.Unlock()
for |
chainLength--
if chainLength > 0 {
ltc = LTC6813.New(spiConnection, chainLength)
if err := ltc.Initialise(); err != nil {
fmt.Print(err)
log.Fatal(err)
}
_, err := ltc.MeasureVoltages()
if err != nil {
fmt.Println("MeasureVoltages - ", err)
}
_, err = ltc.MeasureTemperatures()
if err != nil {
fmt.Println("MeasureTemperatures - ", err)
}
} else {
ltc = nil
}
return chainLength, nil
}
func performMeasurements() {
var total float32
var err error
var banks int
fmt.Println("Measuring")
if nDevices == 0 {
nDevices, err = getLTC6813()
if err != nil {
fmt.Print(err)
nErrors++
return
}
}
if nDevices == 0 {
fmt.Printf("\033cNo devices found on %s - %s", *spiDevice, time.Now().Format("15:04:05.99"))
return
}
banks, err = ltc.MeasureVoltagesSC()
if err != nil {
// Retry if it failed and ignore the failure if the retry was successful
banks, err = ltc.MeasureVoltagesSC()
}
if err != nil {
fmt.Print(" Error measuring voltages - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
} else {
fmt.Print("\033c")
fmt.Printf("%d LTC6813 found on %s - %s - %d errors.\n", nDevices, *spiDevice, time.Now().Format("15:04:05.99"), nErrors)
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank%2d", bank)
total = 0.0
for cell := 0; cell < 18; cell++ {
fmt.Printf(" : %1.4f", ltc.GetVolts(bank, cell))
total = total + ltc.GetVolts(bank, cell)
}
fmt.Printf(" Sum = %2.3f\n", total)
}
banks, err = ltc.MeasureTemperatures()
if err != nil {
banks, err = ltc.MeasureTemperatures()
}
if err != nil {
fmt.Print(" Error measuring temperatures - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
}
fmt.Println("Temperatures")
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank %d", bank)
for sensor := 0; sensor < 18; sensor++ {
temperature, err := ltc.GetTemperature(bank, sensor)
if err != nil {
fmt.Printf(" : %v ", err)
} else {
fmt.Printf(" : %2.1f℃", temperature)
}
}
fmt.Printf(" - Reference Volts = %1.4f - Sum of Cells = %2.3f\n", ltc.GetRefVolts(bank), ltc.GetSumOfCellsVolts(bank))
}
}
}
func mainImpl() error {
if !*verbose {
log.SetOutput(ioutil.Discard)
}
log.SetFlags(log.Lmicroseconds)
if flag.NArg() != 0 {
return errors.New("unexpected argument, try -help")
}
for {
nDevices, err := getLTC6813()
if err == nil && nDevices > 0 {
break
}
fmt.Println("Looking for a device")
}
done := make(chan bool)
ticker := time.NewTicker(time.Second)
go func() {
for {
select {
case <-done:
return
case <-ticker.C:
performMeasurements()
}
}
}()
// Configure and start the WEB server
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", getValues).Methods("GET")
router.HandleFunc("/version", getVersion).Methods("GET")
router.HandleFunc("/i2cread", getI2Cread).Methods("GET")
router.HandleFunc("/i2cwrite", getI2Cwrite).Methods("GET")
router.HandleFunc("/i2creadByte", getI2CreadByte).Methods("GET")
router.HandleFunc("/i2cVoltage", getI2CVoltage).Methods("GET")
router.HandleFunc("/i2cCharge", getI2CCharge).Methods("GET")
router.HandleFunc("/i2cCurrent", getI2CCurrent).Methods("GET")
router.HandleFunc("/i2cTemp", getI2CTemp).Methods("GET")
http.ListenAndServe(":8080", router) // Listen on port 8080
return nil
}
func connectToDatabase() (*sql.DB, error) {
if pDB != nil {
_ = pDB.Close()
pDB = nil
}
var sConnectionString = *pDatabaseLogin + ":" + *pDatabasePassword + "@tcp(" + *pDatabaseServer + ":" + *pDatabasePort + ")/" + *pDatabaseName
fmt.Println("Connecting to [", sConnectionString, "]")
db, err := sql.Open("mysql", sConnectionString)
if err != nil {
return nil, err
}
err = db.Ping()
if err != nil {
_ = db.Close()
return nil, err
}
return db, err
}
func init() {
verbose = flag.Bool("v", false, "verbose mode")
spiDevice = flag.String("c", "/dev/spidev0.1", "SPI device from /dev")
pDatabaseLogin = flag.String("l", "logger", "Database Login ID")
pDatabasePassword = flag.String("p", "logger", "Database password")
pDatabaseServer = flag.String("s", "localhost", "Database server")
pDatabasePort = flag.String("o", "3306", "Database port")
pDatabaseName = flag.String("d", "battery", "Name of the database")
flag.Parse()
logwriter, e := syslog.New(syslog.LOG_NOTICE, "Hello")
if e == nil {
log.SetOutput(logwriter)
}
// Initialise the SPI subsystem
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
p, err := spireg.Open(*spiDevice)
if err != nil {
log.Fatal(err)
}
spiConnection, err = p.Connect(SPI_BAUD_RATE, spi.Mode0, SPI_BITS_PER_WORD)
if err != nil {
log.Fatal(err)
}
nErrors = 0
// Set up the database connection
pDB, err = connectToDatabase()
if err != nil {
log.Fatalf("Failed to connect to to the database - %s - Sorry, I am giving up.", err)
}
}
/*
WEB Service to return the version information
*/
func getVersion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, `<html>
<head>
<Cedar Technology Battery Manager>
</head>
<body>
<h1>Cedar Technology Battery Manager</h1>
<h2>Version 1.0 - January 10th 2020</h2>
</body>
</html>`)
}
/*
WEB service to return current process values
*/
func getValues(w http.ResponseWriter, _ *http.Request) {
ltc_lock.Lock()
defer ltc_lock.Unlock()
// This header allows the output to be used in a WEB page from another server as a data source for some controls
w.Header().Set("Access-Control-Allow-Origin", "*")
if ltc != nil {
_, _ = fmt.Fprintf(w, `{%s,%s}`, ltc.GetVoltagesAsJSON(), ltc.GetTemperaturesAsJSON())
} else {
_, _ = fmt.Fprint(w, `{"error":"No Devices"}`)
}
}
/**
WEB service to read the I2C port
*/
func getI2Cread(w http.ResponseWriter, r *http.Request) {
var reg int64
sReg := r.URL.Query().Get("reg")
if sReg != "" {
reg, _ = strconv.ParseInt(sReg, 0, 8)
} else {
reg = 0x1a
}
sensor, _ := strconv.ParseInt(r.URL.Query().Get("sensor"), 0, 8)
s, err := ltc.ReadI2CWord(int(sensor), LTC6813.LTC2944Address, uint8(reg))
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, "Request = ", r.URL.Query().Get("reg"), "\n")
if err != | {
testLtc := LTC6813.New(spiConnection, chainLength)
if _, err := testLtc.Test(); err != nil {
fmt.Println(err)
break
}
testLtc = nil
chainLength++
} | conditional_block |
BatteryMonitor6813Tester.go | {
nDevices, err = getLTC6813()
if err != nil {
fmt.Print(err)
nErrors++
return
}
}
if nDevices == 0 {
fmt.Printf("\033cNo devices found on %s - %s", *spiDevice, time.Now().Format("15:04:05.99"))
return
}
banks, err = ltc.MeasureVoltagesSC()
if err != nil {
// Retry if it failed and ignore the failure if the retry was successful
banks, err = ltc.MeasureVoltagesSC()
}
if err != nil {
fmt.Print(" Error measuring voltages - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
} else {
fmt.Print("\033c")
fmt.Printf("%d LTC6813 found on %s - %s - %d errors.\n", nDevices, *spiDevice, time.Now().Format("15:04:05.99"), nErrors)
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank%2d", bank)
total = 0.0
for cell := 0; cell < 18; cell++ {
fmt.Printf(" : %1.4f", ltc.GetVolts(bank, cell))
total = total + ltc.GetVolts(bank, cell)
}
fmt.Printf(" Sum = %2.3f\n", total)
}
banks, err = ltc.MeasureTemperatures()
if err != nil {
banks, err = ltc.MeasureTemperatures()
}
if err != nil {
fmt.Print(" Error measuring temperatures - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
}
fmt.Println("Temperatures")
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank %d", bank)
for sensor := 0; sensor < 18; sensor++ {
temperature, err := ltc.GetTemperature(bank, sensor)
if err != nil {
fmt.Printf(" : %v ", err)
} else {
fmt.Printf(" : %2.1f℃", temperature)
}
}
fmt.Printf(" - Reference Volts = %1.4f - Sum of Cells = %2.3f\n", ltc.GetRefVolts(bank), ltc.GetSumOfCellsVolts(bank))
}
}
}
func mainImpl() error {
if !*verbose {
log.SetOutput(ioutil.Discard)
}
log.SetFlags(log.Lmicroseconds)
if flag.NArg() != 0 {
return errors.New("unexpected argument, try -help")
}
for {
nDevices, err := getLTC6813()
if err == nil && nDevices > 0 {
break
}
fmt.Println("Looking for a device")
}
done := make(chan bool)
ticker := time.NewTicker(time.Second)
go func() {
for {
select {
case <-done:
return
case <-ticker.C:
performMeasurements()
}
}
}()
// Configure and start the WEB server
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", getValues).Methods("GET")
router.HandleFunc("/version", getVersion).Methods("GET")
router.HandleFunc("/i2cread", getI2Cread).Methods("GET")
router.HandleFunc("/i2cwrite", getI2Cwrite).Methods("GET")
router.HandleFunc("/i2creadByte", getI2CreadByte).Methods("GET")
router.HandleFunc("/i2cVoltage", getI2CVoltage).Methods("GET")
router.HandleFunc("/i2cCharge", getI2CCharge).Methods("GET")
router.HandleFunc("/i2cCurrent", getI2CCurrent).Methods("GET")
router.HandleFunc("/i2cTemp", getI2CTemp).Methods("GET")
http.ListenAndServe(":8080", router) // Listen on port 8080
return nil
}
func connectToDatabase() (*sql.DB, error) {
if pDB != nil {
_ = pDB.Close()
pDB = nil
}
var sConnectionString = *pDatabaseLogin + ":" + *pDatabasePassword + "@tcp(" + *pDatabaseServer + ":" + *pDatabasePort + ")/" + *pDatabaseName
fmt.Println("Connecting to [", sConnectionString, "]")
db, err := sql.Open("mysql", sConnectionString)
if err != nil {
return nil, err
}
err = db.Ping()
if err != nil {
_ = db.Close()
return nil, err
}
return db, err
}
func init() {
verbose = flag.Bool("v", false, "verbose mode")
spiDevice = flag.String("c", "/dev/spidev0.1", "SPI device from /dev")
pDatabaseLogin = flag.String("l", "logger", "Database Login ID")
pDatabasePassword = flag.String("p", "logger", "Database password")
pDatabaseServer = flag.String("s", "localhost", "Database server")
pDatabasePort = flag.String("o", "3306", "Database port")
pDatabaseName = flag.String("d", "battery", "Name of the database")
flag.Parse()
logwriter, e := syslog.New(syslog.LOG_NOTICE, "Hello")
if e == nil {
log.SetOutput(logwriter)
}
// Initialise the SPI subsystem
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
p, err := spireg.Open(*spiDevice)
if err != nil {
log.Fatal(err)
}
spiConnection, err = p.Connect(SPI_BAUD_RATE, spi.Mode0, SPI_BITS_PER_WORD)
if err != nil {
log.Fatal(err)
}
nErrors = 0
// Set up the database connection
pDB, err = connectToDatabase()
if err != nil {
log.Fatalf("Failed to connect to to the database - %s - Sorry, I am giving up.", err)
}
}
/*
WEB Service to return the version information
*/
func getVersion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, `<html>
<head>
<Cedar Technology Battery Manager>
</head>
<body>
<h1>Cedar Technology Battery Manager</h1>
<h2>Version 1.0 - January 10th 2020</h2>
</body>
</html>`)
}
/*
WEB service to return current process values
*/
func getValues(w http.ResponseWriter, _ *http.Request) {
ltc_lock.Lock()
defer ltc_lock.Unlock()
// This header allows the output to be used in a WEB page from another server as a data source for some controls
w.Header().Set("Access-Control-Allow-Origin", "*")
if ltc != nil {
_, _ = fmt.Fprintf(w, `{%s,%s}`, ltc.GetVoltagesAsJSON(), ltc.GetTemperaturesAsJSON())
} else {
_, _ = fmt.Fprint(w, `{"error":"No Devices"}`)
}
}
/**
WEB service to read the I2C port
*/
func getI2Cread(w http.ResponseWriter, r *http.Request) {
var reg int64
sReg := r.URL.Query().Get("reg")
if sReg != "" {
reg, _ = strconv.ParseInt(sReg, 0, 8)
} else {
reg = 0x1a
}
sensor, _ := strconv.ParseInt(r.URL.Query().Get("sensor"), 0, 8)
s, err := ltc.ReadI2CWord(int(sensor), LTC6813.LTC2944Address, uint8(reg))
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, "Request = ", r.URL.Query().Get("reg"), "\n")
if err != nil {
fmt.Fprint(w, "Error - ", err)
} else {
fmt.Fprintf(w, s)
}
}
/**
WEB service to read one 8 bit register from the I2C port
*/
func getI2CreadByte(w http.ResponseWriter, r *http.Request) {
sensor, _ := strconv.ParseInt(r.URL.Query().Get("sensor"), 0, 8)
var reg int64
sReg := r.URL.Query().Get("reg")
if sReg != "" {
reg, _ = strconv.ParseInt(sReg, 0, 8)
} else {
reg = 0x1a
}
s, err := ltc.ReadI2CByte(int(sensor), LTC6813.LTC2944Address, uint8(reg))
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, "Request = ", r.URL.Query().Get("reg"), "\n")
if err != nil {
fmt.Fprint(w, "Error - ", err)
} else {
fmt.Fprintf(w, s)
}
} |
/**
WEB service to read the current from the I2C port
*/
func getI2CCurrent(w http.ResponseWriter, r *http.Request) { | random_line_split |
|
BatteryMonitor6813Tester.go | TC6813.New(spiConnection, 2).Initialise()
//
// }
ltc_lock.Lock()
defer ltc_lock.Unlock()
for {
testLtc := LTC6813.New(spiConnection, chainLength)
if _, err := testLtc.Test(); err != nil {
fmt.Println(err)
break
}
testLtc = nil
chainLength++
}
chainLength--
if chainLength > 0 {
ltc = LTC6813.New(spiConnection, chainLength)
if err := ltc.Initialise(); err != nil {
fmt.Print(err)
log.Fatal(err)
}
_, err := ltc.MeasureVoltages()
if err != nil {
fmt.Println("MeasureVoltages - ", err)
}
_, err = ltc.MeasureTemperatures()
if err != nil {
fmt.Println("MeasureTemperatures - ", err)
}
} else {
ltc = nil
}
return chainLength, nil
}
func performMeasurements() {
var total float32
var err error
var banks int
fmt.Println("Measuring")
if nDevices == 0 {
nDevices, err = getLTC6813()
if err != nil {
fmt.Print(err)
nErrors++
return
}
}
if nDevices == 0 {
fmt.Printf("\033cNo devices found on %s - %s", *spiDevice, time.Now().Format("15:04:05.99"))
return
}
banks, err = ltc.MeasureVoltagesSC()
if err != nil {
// Retry if it failed and ignore the failure if the retry was successful
banks, err = ltc.MeasureVoltagesSC()
}
if err != nil {
fmt.Print(" Error measuring voltages - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
} else {
fmt.Print("\033c")
fmt.Printf("%d LTC6813 found on %s - %s - %d errors.\n", nDevices, *spiDevice, time.Now().Format("15:04:05.99"), nErrors)
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank%2d", bank)
total = 0.0
for cell := 0; cell < 18; cell++ {
fmt.Printf(" : %1.4f", ltc.GetVolts(bank, cell))
total = total + ltc.GetVolts(bank, cell)
}
fmt.Printf(" Sum = %2.3f\n", total)
}
banks, err = ltc.MeasureTemperatures()
if err != nil {
banks, err = ltc.MeasureTemperatures()
}
if err != nil {
fmt.Print(" Error measuring temperatures - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
}
fmt.Println("Temperatures")
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank %d", bank)
for sensor := 0; sensor < 18; sensor++ {
temperature, err := ltc.GetTemperature(bank, sensor)
if err != nil {
fmt.Printf(" : %v ", err)
} else {
fmt.Printf(" : %2.1f℃", temperature)
}
}
fmt.Printf(" - Reference Volts = %1.4f - Sum of Cells = %2.3f\n", ltc.GetRefVolts(bank), ltc.GetSumOfCellsVolts(bank))
}
}
}
func mainImpl() error {
if !*verbose {
log.SetOutput(ioutil.Discard)
}
log.SetFlags(log.Lmicroseconds)
if flag.NArg() != 0 {
return errors.New("unexpected argument, try -help")
}
for {
nDevices, err := getLTC6813()
if err == nil && nDevices > 0 {
break
}
fmt.Println("Looking for a device")
}
done := make(chan bool)
ticker := time.NewTicker(time.Second)
go func() {
for {
select {
case <-done:
return
case <-ticker.C:
performMeasurements()
}
}
}()
// Configure and start the WEB server
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", getValues).Methods("GET")
router.HandleFunc("/version", getVersion).Methods("GET")
router.HandleFunc("/i2cread", getI2Cread).Methods("GET")
router.HandleFunc("/i2cwrite", getI2Cwrite).Methods("GET")
router.HandleFunc("/i2creadByte", getI2CreadByte).Methods("GET")
router.HandleFunc("/i2cVoltage", getI2CVoltage).Methods("GET")
router.HandleFunc("/i2cCharge", getI2CCharge).Methods("GET")
router.HandleFunc("/i2cCurrent", getI2CCurrent).Methods("GET")
router.HandleFunc("/i2cTemp", getI2CTemp).Methods("GET")
http.ListenAndServe(":8080", router) // Listen on port 8080
return nil
}
func co | (*sql.DB, error) {
if pDB != nil {
_ = pDB.Close()
pDB = nil
}
var sConnectionString = *pDatabaseLogin + ":" + *pDatabasePassword + "@tcp(" + *pDatabaseServer + ":" + *pDatabasePort + ")/" + *pDatabaseName
fmt.Println("Connecting to [", sConnectionString, "]")
db, err := sql.Open("mysql", sConnectionString)
if err != nil {
return nil, err
}
err = db.Ping()
if err != nil {
_ = db.Close()
return nil, err
}
return db, err
}
func init() {
verbose = flag.Bool("v", false, "verbose mode")
spiDevice = flag.String("c", "/dev/spidev0.1", "SPI device from /dev")
pDatabaseLogin = flag.String("l", "logger", "Database Login ID")
pDatabasePassword = flag.String("p", "logger", "Database password")
pDatabaseServer = flag.String("s", "localhost", "Database server")
pDatabasePort = flag.String("o", "3306", "Database port")
pDatabaseName = flag.String("d", "battery", "Name of the database")
flag.Parse()
logwriter, e := syslog.New(syslog.LOG_NOTICE, "Hello")
if e == nil {
log.SetOutput(logwriter)
}
// Initialise the SPI subsystem
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
p, err := spireg.Open(*spiDevice)
if err != nil {
log.Fatal(err)
}
spiConnection, err = p.Connect(SPI_BAUD_RATE, spi.Mode0, SPI_BITS_PER_WORD)
if err != nil {
log.Fatal(err)
}
nErrors = 0
// Set up the database connection
pDB, err = connectToDatabase()
if err != nil {
log.Fatalf("Failed to connect to to the database - %s - Sorry, I am giving up.", err)
}
}
/*
WEB Service to return the version information
*/
func getVersion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, `<html>
<head>
<Cedar Technology Battery Manager>
</head>
<body>
<h1>Cedar Technology Battery Manager</h1>
<h2>Version 1.0 - January 10th 2020</h2>
</body>
</html>`)
}
/*
WEB service to return current process values
*/
func getValues(w http.ResponseWriter, _ *http.Request) {
ltc_lock.Lock()
defer ltc_lock.Unlock()
// This header allows the output to be used in a WEB page from another server as a data source for some controls
w.Header().Set("Access-Control-Allow-Origin", "*")
if ltc != nil {
_, _ = fmt.Fprintf(w, `{%s,%s}`, ltc.GetVoltagesAsJSON(), ltc.GetTemperaturesAsJSON())
} else {
_, _ = fmt.Fprint(w, `{"error":"No Devices"}`)
}
}
/**
WEB service to read the I2C port
*/
func getI2Cread(w http.ResponseWriter, r *http.Request) {
var reg int64
sReg := r.URL.Query().Get("reg")
if sReg != "" {
reg, _ = strconv.ParseInt(sReg, 0, 8)
} else {
reg = 0x1a
}
sensor, _ := strconv.ParseInt(r.URL.Query().Get("sensor"), 0, 8)
s, err := ltc.ReadI2CWord(int(sensor), LTC6813.LTC2944Address, uint8(reg))
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, "Request = ", r.URL.Query().Get("reg"), "\n")
if err != | nnectToDatabase() | identifier_name |
BatteryMonitor6813Tester.go | LTC6813.New(spiConnection, 2).Initialise()
//
// }
ltc_lock.Lock()
defer ltc_lock.Unlock()
for {
testLtc := LTC6813.New(spiConnection, chainLength)
if _, err := testLtc.Test(); err != nil {
fmt.Println(err)
break
}
testLtc = nil
chainLength++
}
chainLength--
if chainLength > 0 {
ltc = LTC6813.New(spiConnection, chainLength)
if err := ltc.Initialise(); err != nil {
fmt.Print(err)
log.Fatal(err)
}
_, err := ltc.MeasureVoltages()
if err != nil {
fmt.Println("MeasureVoltages - ", err)
}
_, err = ltc.MeasureTemperatures()
if err != nil {
fmt.Println("MeasureTemperatures - ", err)
}
} else {
ltc = nil
}
return chainLength, nil
}
func performMeasurements() {
var total float32
var err error
var banks int
fmt.Println("Measuring")
if nDevices == 0 {
nDevices, err = getLTC6813()
if err != nil {
fmt.Print(err)
nErrors++
return
}
}
if nDevices == 0 {
fmt.Printf("\033cNo devices found on %s - %s", *spiDevice, time.Now().Format("15:04:05.99"))
return
}
banks, err = ltc.MeasureVoltagesSC()
if err != nil {
// Retry if it failed and ignore the failure if the retry was successful
banks, err = ltc.MeasureVoltagesSC()
}
if err != nil {
fmt.Print(" Error measuring voltages - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
} else {
fmt.Print("\033c")
fmt.Printf("%d LTC6813 found on %s - %s - %d errors.\n", nDevices, *spiDevice, time.Now().Format("15:04:05.99"), nErrors)
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank%2d", bank)
total = 0.0
for cell := 0; cell < 18; cell++ {
fmt.Printf(" : %1.4f", ltc.GetVolts(bank, cell))
total = total + ltc.GetVolts(bank, cell)
}
fmt.Printf(" Sum = %2.3f\n", total)
}
banks, err = ltc.MeasureTemperatures()
if err != nil {
banks, err = ltc.MeasureTemperatures()
}
if err != nil {
fmt.Print(" Error measuring temperatures - ", err)
time.Sleep(time.Second * 2)
nDevices = 0
nErrors++
}
fmt.Println("Temperatures")
for bank := 0; bank < banks; bank++ {
fmt.Printf("Bank %d", bank)
for sensor := 0; sensor < 18; sensor++ {
temperature, err := ltc.GetTemperature(bank, sensor)
if err != nil {
fmt.Printf(" : %v ", err)
} else {
fmt.Printf(" : %2.1f℃", temperature)
}
}
fmt.Printf(" - Reference Volts = %1.4f - Sum of Cells = %2.3f\n", ltc.GetRefVolts(bank), ltc.GetSumOfCellsVolts(bank))
}
}
}
func mainImpl() error {
| select {
case <-done:
return
case <-ticker.C:
performMeasurements()
}
}
}()
// Configure and start the WEB server
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", getValues).Methods("GET")
router.HandleFunc("/version", getVersion).Methods("GET")
router.HandleFunc("/i2cread", getI2Cread).Methods("GET")
router.HandleFunc("/i2cwrite", getI2Cwrite).Methods("GET")
router.HandleFunc("/i2creadByte", getI2CreadByte).Methods("GET")
router.HandleFunc("/i2cVoltage", getI2CVoltage).Methods("GET")
router.HandleFunc("/i2cCharge", getI2CCharge).Methods("GET")
router.HandleFunc("/i2cCurrent", getI2CCurrent).Methods("GET")
router.HandleFunc("/i2cTemp", getI2CTemp).Methods("GET")
http.ListenAndServe(":8080", router) // Listen on port 8080
return nil
}
func connectToDatabase() (*sql.DB, error) {
if pDB != nil {
_ = pDB.Close()
pDB = nil
}
var sConnectionString = *pDatabaseLogin + ":" + *pDatabasePassword + "@tcp(" + *pDatabaseServer + ":" + *pDatabasePort + ")/" + *pDatabaseName
fmt.Println("Connecting to [", sConnectionString, "]")
db, err := sql.Open("mysql", sConnectionString)
if err != nil {
return nil, err
}
err = db.Ping()
if err != nil {
_ = db.Close()
return nil, err
}
return db, err
}
func init() {
verbose = flag.Bool("v", false, "verbose mode")
spiDevice = flag.String("c", "/dev/spidev0.1", "SPI device from /dev")
pDatabaseLogin = flag.String("l", "logger", "Database Login ID")
pDatabasePassword = flag.String("p", "logger", "Database password")
pDatabaseServer = flag.String("s", "localhost", "Database server")
pDatabasePort = flag.String("o", "3306", "Database port")
pDatabaseName = flag.String("d", "battery", "Name of the database")
flag.Parse()
logwriter, e := syslog.New(syslog.LOG_NOTICE, "Hello")
if e == nil {
log.SetOutput(logwriter)
}
// Initialise the SPI subsystem
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
p, err := spireg.Open(*spiDevice)
if err != nil {
log.Fatal(err)
}
spiConnection, err = p.Connect(SPI_BAUD_RATE, spi.Mode0, SPI_BITS_PER_WORD)
if err != nil {
log.Fatal(err)
}
nErrors = 0
// Set up the database connection
pDB, err = connectToDatabase()
if err != nil {
log.Fatalf("Failed to connect to to the database - %s - Sorry, I am giving up.", err)
}
}
/*
WEB Service to return the version information
*/
func getVersion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, `<html>
<head>
<Cedar Technology Battery Manager>
</head>
<body>
<h1>Cedar Technology Battery Manager</h1>
<h2>Version 1.0 - January 10th 2020</h2>
</body>
</html>`)
}
/*
WEB service to return current process values
*/
func getValues(w http.ResponseWriter, _ *http.Request) {
ltc_lock.Lock()
defer ltc_lock.Unlock()
// This header allows the output to be used in a WEB page from another server as a data source for some controls
w.Header().Set("Access-Control-Allow-Origin", "*")
if ltc != nil {
_, _ = fmt.Fprintf(w, `{%s,%s}`, ltc.GetVoltagesAsJSON(), ltc.GetTemperaturesAsJSON())
} else {
_, _ = fmt.Fprint(w, `{"error":"No Devices"}`)
}
}
/**
WEB service to read the I2C port
*/
func getI2Cread(w http.ResponseWriter, r *http.Request) {
var reg int64
sReg := r.URL.Query().Get("reg")
if sReg != "" {
reg, _ = strconv.ParseInt(sReg, 0, 8)
} else {
reg = 0x1a
}
sensor, _ := strconv.ParseInt(r.URL.Query().Get("sensor"), 0, 8)
s, err := ltc.ReadI2CWord(int(sensor), LTC6813.LTC2944Address, uint8(reg))
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprint(w, "Request = ", r.URL.Query().Get("reg"), "\n")
if err != nil | if !*verbose {
log.SetOutput(ioutil.Discard)
}
log.SetFlags(log.Lmicroseconds)
if flag.NArg() != 0 {
return errors.New("unexpected argument, try -help")
}
for {
nDevices, err := getLTC6813()
if err == nil && nDevices > 0 {
break
}
fmt.Println("Looking for a device")
}
done := make(chan bool)
ticker := time.NewTicker(time.Second)
go func() {
for { | identifier_body |
image_caption.py | # Loading cap as values and images as key in dictionary
tok = {}
for item in range(len(cap)-1):
tem = cap[item].split("#") #tem[0]= imgname.jpg ..... tem[1]=0 captionn.
if tem[0] in tok:
tok[tem[0]].append(tem[1][2:])
else:
tok[tem[0]] = [tem[1][2:]] #tem[n]= imgName ... #tok[tem[n]] = list of caption
# Making 3 files with 2 colmns as 'image_id' and 'captions'
training_dataset = open('flickr_8k_train_dataset.txt','wb')
training_dataset.write(b"image_id\tcap\n")
valid_dataset = open('flickr_8k_val_dataset.txt','wb')
valid_dataset.write(b"image_id\tcap\n")
testing_dataset = open('flickr_8k_test_dataset.txt','wb')
testing_dataset.write(b"image_id\tcap\n")
# Loading image ids and captions for each of these images in the above 3 files
for img in x_training:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
training_dataset.write((img+"\t"+caption+"\n").encode())
training_dataset.flush()
training_dataset.close()
for img in x_testing:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
testing_dataset.write((img+"\t"+caption+"\n").encode())
testing_dataset.flush()
testing_dataset.close()
for img in x_valid:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
valid_dataset.write((img+"\t"+caption+"\n").encode())
valid_dataset.flush()
valid_dataset.close()
# Here, we're using ResNet50 Model
from IPython.core.display import display, HTML
model = ResNet50(include_top=False,weights='imagenet',input_shape=(224,224,3),pooling='avg')
model.summary()
# process images to target size
def preprocess(img_path):
im = image.load_img(img_path, target_size=(224,224,3))
im = image.img_to_array(im) # (x, y, z)
im = np.expand_dims(im, axis=0) # (0, x, y, z)
return im
training_data = {}
counter=0
for item in x_training:
if item == "":
continue
if counter >= 3000:
break
counter+=1
if counter%1000==0:
print(counter)
path = img_path + item
img = preprocess(path) #to change the dimensions of the image for using ResNet model
pred = model.predict(img).reshape(2048) # shape of each image is (2048, 0)
training_data[item] = pred
# opening train_enc_img.p file and dumping content of training_data to this file
with open( "train_enc_img.p", "wb" ) as pickle_f: #obj hierarchy is converted into byte stream
pickle.dump(training_data, pickle_f )
# Storing image and its corresponding caption into a dataframe
pd_dataset = pd.read_csv("flickr_8k_train_dataset.txt", delimiter='\t')
dframe = pd_dataset.values
print(dframe.shape)
pd_dataset.head()
# Storing all the captions from dframe into a list
senten = []
for item in range(dframe.shape[0]):
senten.append(dframe[item, 1])
#senten will have 30000 length
# First 5 captions stored in senten
senten[:5]
# Splitting each captions stored in 'senten' and storing them in 'wor' as list of list
wor = [i.split() for i in senten]
# Creating a list of all unique wor
uniq = []
for i in wor:
uniq.extend(i)
uniq = list(set(uniq))
print(len(uniq))
vocabulary_size = len(uniq)
# making 2 lists to index each unique word and vice-versa
w_to_i = {val:index for index, val in enumerate(uniq)}
i_to_w = {index:val for index, val in enumerate(uniq)}
w_to_i['UNK'] = 0
w_to_i['raining'] = 8253
i_to_w[0] = 'UNK'
i_to_w[8253] = 'raining'
vocabulary_size = len(w_to_i.keys())
print(vocabulary_size)
max_len = 0
for i in senten:
i = i.split()
if len(i) > max_len:
max_len = len(i)
print(max_len) #finding longest caption
pad_seq, subsequent_wor = [], []
for item in range(dframe.shape[0]): #30000 items
part_seq = []
next_wor = []
text = dframe[item, 1].split() #diving each caption for every image into words
text = [w_to_i[i] for i in text] #finding index for each word
for i in range(1, len(text)):
part_seq.append(text[:i]) #start, 1st word, ... , last word
next_wor.append(text[i]) #1st word, ... , last word, end
pad_part_seq = sequence.pad_sequences(part_seq, max_len, padding='post')
next_wor_1hot = np.zeros([len(next_wor), vocabulary_size], dtype=np.bool)
for i,next_word in enumerate(next_wor):
next_wor_1hot[i, next_word] = 1
pad_seq.append(pad_part_seq )
subsequent_wor.append(next_wor_1hot)
pad_seq = np.asarray(pad_seq)
subsequent_wor = np.asarray(subsequent_wor)
print(pad_seq.shape)
print(subsequent_wor.shape)
print(pad_seq[0])
for item in range(len(pad_seq[0])):
for y in range(max_len):
print(i_to_w[pad_seq[0][item][y]],)
print("\n")
print(len(pad_seq[0]))
num_imgs = 2000
cap = np.zeros([0, max_len])
next_wor = np.zeros([0, vocabulary_size])
for item in range(num_imgs): #img_to_padded_seqs.shape[0]):
cap = np.concatenate([cap, pad_seq[item]])
next_wor = np.concatenate([next_wor, subsequent_wor[item]])
np.save("cap.npy", cap)
np.save("next_wor.npy", next_wor)
print(cap.shape)
print(next_wor.shape)
with open('train_enc_img.p', 'rb') as f:
enc_img = pickle.load(f, encoding="bytes")
imgs = []
for item in range(dframe.shape[0]): #30000
if dframe[item, 0] in enc_img.keys(): #dframe[0,0], [1,0], ... , [4,0] match with 0th key of enc_img
imgs.append(list(enc_img[dframe[item, 0]]))
imgs = np.asarray(imgs)
print(imgs.shape)
images = []
img_names = []
for item in range(num_imgs): #2000
for y in range(pad_seq[item].shape[0]): #14
images.append(imgs[item]) #1st iteration: 14 times name of image in byte form
img_names.append(dframe[item, 0]) # normal form
images = np.asarray(images) #images contains image_name in byte form
np.save("images.npy", images)
img_names = np.asarray(img_names) #img_names contains image_name normally
np.save("img_names.npy", img_names)
print(images.shape)
print(len(img_names))
cap = np.load("cap.npy")
next_wor = np.load("next_wor.npy")
print(cap.shape)
print(next_wor.shape)
images = np.load("images.npy")
print(images.shape)
imag = np.load("img_names.npy")
print(imag.shape)
embed_size = 128
max_len = 40
img_model = Sequential()
img_model.add(Dense(embed_size, input_shape=(2048,), activation='relu'))
img_model.add(RepeatVector(max_len))
img_model.summary()
lang_model = Sequential()
lang_model.add(Embedding(input_dim=vocabulary_size, output_dim=embed_size, input_length=max_len))
lang_model.add(LSTM(256, return_sequences=True))
lang_model.add(TimeDistributed(Dense(embed_size)))
lang_model.summary()
concat = Concatenate()([img_model.output, lang_model.output])
x = LSTM(128, return_sequences=True)(concat)
x = LSTM(512, return_sequences=False)(x)
x = Dense(vocabulary_size)(x)
out = Activation('softmax')(x)
model = Model(inputs=[img_model.input, lang_model.input], outputs = out)
model.compile(loss='categorical_crossentropy', optimizer='RMS | x_training = open(training_path, 'r').read().split("\n")
x_valid = open(valid_path, 'r').read().split("\n")
x_testing = open(testing_path , 'r').read().split("\n")
| random_line_split |
|
image_caption.py | flickr_8k_val_dataset.txt','wb')
valid_dataset.write(b"image_id\tcap\n")
testing_dataset = open('flickr_8k_test_dataset.txt','wb')
testing_dataset.write(b"image_id\tcap\n")
# Loading image ids and captions for each of these images in the above 3 files
for img in x_training:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
training_dataset.write((img+"\t"+caption+"\n").encode())
training_dataset.flush()
training_dataset.close()
for img in x_testing:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
testing_dataset.write((img+"\t"+caption+"\n").encode())
testing_dataset.flush()
testing_dataset.close()
for img in x_valid:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
valid_dataset.write((img+"\t"+caption+"\n").encode())
valid_dataset.flush()
valid_dataset.close()
# Here, we're using ResNet50 Model
from IPython.core.display import display, HTML
model = ResNet50(include_top=False,weights='imagenet',input_shape=(224,224,3),pooling='avg')
model.summary()
# process images to target size
def preprocess(img_path):
im = image.load_img(img_path, target_size=(224,224,3))
im = image.img_to_array(im) # (x, y, z)
im = np.expand_dims(im, axis=0) # (0, x, y, z)
return im
training_data = {}
counter=0
for item in x_training:
if item == "":
continue
if counter >= 3000:
break
counter+=1
if counter%1000==0:
print(counter)
path = img_path + item
img = preprocess(path) #to change the dimensions of the image for using ResNet model
pred = model.predict(img).reshape(2048) # shape of each image is (2048, 0)
training_data[item] = pred
# opening train_enc_img.p file and dumping content of training_data to this file
with open( "train_enc_img.p", "wb" ) as pickle_f: #obj hierarchy is converted into byte stream
pickle.dump(training_data, pickle_f )
# Storing image and its corresponding caption into a dataframe
pd_dataset = pd.read_csv("flickr_8k_train_dataset.txt", delimiter='\t')
dframe = pd_dataset.values
print(dframe.shape)
pd_dataset.head()
# Storing all the captions from dframe into a list
senten = []
for item in range(dframe.shape[0]):
senten.append(dframe[item, 1])
#senten will have 30000 length
# First 5 captions stored in senten
senten[:5]
# Splitting each captions stored in 'senten' and storing them in 'wor' as list of list
wor = [i.split() for i in senten]
# Creating a list of all unique wor
uniq = []
for i in wor:
uniq.extend(i)
uniq = list(set(uniq))
print(len(uniq))
vocabulary_size = len(uniq)
# making 2 lists to index each unique word and vice-versa
w_to_i = {val:index for index, val in enumerate(uniq)}
i_to_w = {index:val for index, val in enumerate(uniq)}
w_to_i['UNK'] = 0
w_to_i['raining'] = 8253
i_to_w[0] = 'UNK'
i_to_w[8253] = 'raining'
vocabulary_size = len(w_to_i.keys())
print(vocabulary_size)
max_len = 0
for i in senten:
i = i.split()
if len(i) > max_len:
max_len = len(i)
print(max_len) #finding longest caption
pad_seq, subsequent_wor = [], []
for item in range(dframe.shape[0]): #30000 items
part_seq = []
next_wor = []
text = dframe[item, 1].split() #diving each caption for every image into words
text = [w_to_i[i] for i in text] #finding index for each word
for i in range(1, len(text)):
part_seq.append(text[:i]) #start, 1st word, ... , last word
next_wor.append(text[i]) #1st word, ... , last word, end
pad_part_seq = sequence.pad_sequences(part_seq, max_len, padding='post')
next_wor_1hot = np.zeros([len(next_wor), vocabulary_size], dtype=np.bool)
for i,next_word in enumerate(next_wor):
next_wor_1hot[i, next_word] = 1
pad_seq.append(pad_part_seq )
subsequent_wor.append(next_wor_1hot)
pad_seq = np.asarray(pad_seq)
subsequent_wor = np.asarray(subsequent_wor)
print(pad_seq.shape)
print(subsequent_wor.shape)
print(pad_seq[0])
for item in range(len(pad_seq[0])):
for y in range(max_len):
print(i_to_w[pad_seq[0][item][y]],)
print("\n")
print(len(pad_seq[0]))
num_imgs = 2000
cap = np.zeros([0, max_len])
next_wor = np.zeros([0, vocabulary_size])
for item in range(num_imgs): #img_to_padded_seqs.shape[0]):
cap = np.concatenate([cap, pad_seq[item]])
next_wor = np.concatenate([next_wor, subsequent_wor[item]])
np.save("cap.npy", cap)
np.save("next_wor.npy", next_wor)
print(cap.shape)
print(next_wor.shape)
with open('train_enc_img.p', 'rb') as f:
enc_img = pickle.load(f, encoding="bytes")
imgs = []
for item in range(dframe.shape[0]): #30000
if dframe[item, 0] in enc_img.keys(): #dframe[0,0], [1,0], ... , [4,0] match with 0th key of enc_img
imgs.append(list(enc_img[dframe[item, 0]]))
imgs = np.asarray(imgs)
print(imgs.shape)
images = []
img_names = []
for item in range(num_imgs): #2000
for y in range(pad_seq[item].shape[0]): #14
images.append(imgs[item]) #1st iteration: 14 times name of image in byte form
img_names.append(dframe[item, 0]) # normal form
images = np.asarray(images) #images contains image_name in byte form
np.save("images.npy", images)
img_names = np.asarray(img_names) #img_names contains image_name normally
np.save("img_names.npy", img_names)
print(images.shape)
print(len(img_names))
cap = np.load("cap.npy")
next_wor = np.load("next_wor.npy")
print(cap.shape)
print(next_wor.shape)
images = np.load("images.npy")
print(images.shape)
imag = np.load("img_names.npy")
print(imag.shape)
embed_size = 128
max_len = 40
img_model = Sequential()
img_model.add(Dense(embed_size, input_shape=(2048,), activation='relu'))
img_model.add(RepeatVector(max_len))
img_model.summary()
lang_model = Sequential()
lang_model.add(Embedding(input_dim=vocabulary_size, output_dim=embed_size, input_length=max_len))
lang_model.add(LSTM(256, return_sequences=True))
lang_model.add(TimeDistributed(Dense(embed_size)))
lang_model.summary()
concat = Concatenate()([img_model.output, lang_model.output])
x = LSTM(128, return_sequences=True)(concat)
x = LSTM(512, return_sequences=False)(x)
x = Dense(vocabulary_size)(x)
out = Activation('softmax')(x)
model = Model(inputs=[img_model.input, lang_model.input], outputs = out)
model.compile(loss='categorical_crossentropy', optimizer='RMSprop', metrics=['accuracy'])
model.summary()
hist = model.fit([images, cap], next_wor, batch_size=512, epochs=210)
for label in ["loss"]:
plt.plot(hist.history[label],label=label)
plt.legend()
plt.xlabel("epochs")
plt.ylabel("loss")
plt.show()
for label in ["accuracy"]:
plt.plot(hist.history[label],label=label)
plt.legend()
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.show()
model.save_weights("model_weights.h5")
def preprocess(img_path):
im = image.load_img(img_path, target_size=(224,224,3))
im = image.img_to_array(im) #(224,224,3)
im = np.expand_dims(im, axis=0) #(1,224,224,3)
return im
def get_encode(model, img):
| image = preprocess(img)
pred = model.predict(image).reshape(2048)
return pred | identifier_body |
|
image_caption.py | ")
x_valid = open(valid_path, 'r').read().split("\n")
x_testing = open(testing_path , 'r').read().split("\n")
# Loading cap as values and images as key in dictionary
tok = {}
for item in range(len(cap)-1):
tem = cap[item].split("#") #tem[0]= imgname.jpg ..... tem[1]=0 captionn.
if tem[0] in tok:
tok[tem[0]].append(tem[1][2:])
else:
tok[tem[0]] = [tem[1][2:]] #tem[n]= imgName ... #tok[tem[n]] = list of caption
# Making 3 files with 2 colmns as 'image_id' and 'captions'
training_dataset = open('flickr_8k_train_dataset.txt','wb')
training_dataset.write(b"image_id\tcap\n")
valid_dataset = open('flickr_8k_val_dataset.txt','wb')
valid_dataset.write(b"image_id\tcap\n")
testing_dataset = open('flickr_8k_test_dataset.txt','wb')
testing_dataset.write(b"image_id\tcap\n")
# Loading image ids and captions for each of these images in the above 3 files
for img in x_training:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
training_dataset.write((img+"\t"+caption+"\n").encode())
training_dataset.flush()
training_dataset.close()
for img in x_testing:
|
testing_dataset.close()
for img in x_valid:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
valid_dataset.write((img+"\t"+caption+"\n").encode())
valid_dataset.flush()
valid_dataset.close()
# Here, we're using ResNet50 Model
from IPython.core.display import display, HTML
model = ResNet50(include_top=False,weights='imagenet',input_shape=(224,224,3),pooling='avg')
model.summary()
# process images to target size
def preprocess(img_path):
im = image.load_img(img_path, target_size=(224,224,3))
im = image.img_to_array(im) # (x, y, z)
im = np.expand_dims(im, axis=0) # (0, x, y, z)
return im
training_data = {}
counter=0
for item in x_training:
if item == "":
continue
if counter >= 3000:
break
counter+=1
if counter%1000==0:
print(counter)
path = img_path + item
img = preprocess(path) #to change the dimensions of the image for using ResNet model
pred = model.predict(img).reshape(2048) # shape of each image is (2048, 0)
training_data[item] = pred
# opening train_enc_img.p file and dumping content of training_data to this file
with open( "train_enc_img.p", "wb" ) as pickle_f: #obj hierarchy is converted into byte stream
pickle.dump(training_data, pickle_f )
# Storing image and its corresponding caption into a dataframe
pd_dataset = pd.read_csv("flickr_8k_train_dataset.txt", delimiter='\t')
dframe = pd_dataset.values
print(dframe.shape)
pd_dataset.head()
# Storing all the captions from dframe into a list
senten = []
for item in range(dframe.shape[0]):
senten.append(dframe[item, 1])
#senten will have 30000 length
# First 5 captions stored in senten
senten[:5]
# Splitting each captions stored in 'senten' and storing them in 'wor' as list of list
wor = [i.split() for i in senten]
# Creating a list of all unique wor
uniq = []
for i in wor:
uniq.extend(i)
uniq = list(set(uniq))
print(len(uniq))
vocabulary_size = len(uniq)
# making 2 lists to index each unique word and vice-versa
w_to_i = {val:index for index, val in enumerate(uniq)}
i_to_w = {index:val for index, val in enumerate(uniq)}
w_to_i['UNK'] = 0
w_to_i['raining'] = 8253
i_to_w[0] = 'UNK'
i_to_w[8253] = 'raining'
vocabulary_size = len(w_to_i.keys())
print(vocabulary_size)
max_len = 0
for i in senten:
i = i.split()
if len(i) > max_len:
max_len = len(i)
print(max_len) #finding longest caption
pad_seq, subsequent_wor = [], []
for item in range(dframe.shape[0]): #30000 items
part_seq = []
next_wor = []
text = dframe[item, 1].split() #diving each caption for every image into words
text = [w_to_i[i] for i in text] #finding index for each word
for i in range(1, len(text)):
part_seq.append(text[:i]) #start, 1st word, ... , last word
next_wor.append(text[i]) #1st word, ... , last word, end
pad_part_seq = sequence.pad_sequences(part_seq, max_len, padding='post')
next_wor_1hot = np.zeros([len(next_wor), vocabulary_size], dtype=np.bool)
for i,next_word in enumerate(next_wor):
next_wor_1hot[i, next_word] = 1
pad_seq.append(pad_part_seq )
subsequent_wor.append(next_wor_1hot)
pad_seq = np.asarray(pad_seq)
subsequent_wor = np.asarray(subsequent_wor)
print(pad_seq.shape)
print(subsequent_wor.shape)
print(pad_seq[0])
for item in range(len(pad_seq[0])):
for y in range(max_len):
print(i_to_w[pad_seq[0][item][y]],)
print("\n")
print(len(pad_seq[0]))
num_imgs = 2000
cap = np.zeros([0, max_len])
next_wor = np.zeros([0, vocabulary_size])
for item in range(num_imgs): #img_to_padded_seqs.shape[0]):
cap = np.concatenate([cap, pad_seq[item]])
next_wor = np.concatenate([next_wor, subsequent_wor[item]])
np.save("cap.npy", cap)
np.save("next_wor.npy", next_wor)
print(cap.shape)
print(next_wor.shape)
with open('train_enc_img.p', 'rb') as f:
enc_img = pickle.load(f, encoding="bytes")
imgs = []
for item in range(dframe.shape[0]): #30000
if dframe[item, 0] in enc_img.keys(): #dframe[0,0], [1,0], ... , [4,0] match with 0th key of enc_img
imgs.append(list(enc_img[dframe[item, 0]]))
imgs = np.asarray(imgs)
print(imgs.shape)
images = []
img_names = []
for item in range(num_imgs): #2000
for y in range(pad_seq[item].shape[0]): #14
images.append(imgs[item]) #1st iteration: 14 times name of image in byte form
img_names.append(dframe[item, 0]) # normal form
images = np.asarray(images) #images contains image_name in byte form
np.save("images.npy", images)
img_names = np.asarray(img_names) #img_names contains image_name normally
np.save("img_names.npy", img_names)
print(images.shape)
print(len(img_names))
cap = np.load("cap.npy")
next_wor = np.load("next_wor.npy")
print(cap.shape)
print(next_wor.shape)
images = np.load("images.npy")
print(images.shape)
imag = np.load("img_names.npy")
print(imag.shape)
embed_size = 128
max_len = 40
img_model = Sequential()
img_model.add(Dense(embed_size, input_shape=(2048,), activation='relu'))
img_model.add(RepeatVector(max_len))
img_model.summary()
lang_model = Sequential()
lang_model.add(Embedding(input_dim=vocabulary_size, output_dim=embed_size, input_length=max_len))
lang_model.add(LSTM(256, return_sequences=True))
lang_model.add(TimeDistributed(Dense(embed_size)))
lang_model.summary()
concat = Concatenate()([img_model.output, lang_model.output])
x = LSTM(128, return_sequences=True)(concat)
x = LSTM(512, return_sequences=False)(x)
x = Dense(vocabulary_size)(x)
out = Activation('softmax')(x)
model = Model(inputs=[img_model.input, lang_model.input], outputs = out)
model.compile(loss='categorical_crossentropy', optimizer='RMSprop', metrics=['accuracy'])
model.summary()
hist = model.fit([images | if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
testing_dataset.write((img+"\t"+caption+"\n").encode())
testing_dataset.flush() | conditional_block |
image_caption.py | lickr_8k_train_dataset.txt','wb')
training_dataset.write(b"image_id\tcap\n")
valid_dataset = open('flickr_8k_val_dataset.txt','wb')
valid_dataset.write(b"image_id\tcap\n")
testing_dataset = open('flickr_8k_test_dataset.txt','wb')
testing_dataset.write(b"image_id\tcap\n")
# Loading image ids and captions for each of these images in the above 3 files
for img in x_training:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
training_dataset.write((img+"\t"+caption+"\n").encode())
training_dataset.flush()
training_dataset.close()
for img in x_testing:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
testing_dataset.write((img+"\t"+caption+"\n").encode())
testing_dataset.flush()
testing_dataset.close()
for img in x_valid:
if img == '':
continue
for capt in tok[img]:
caption = "<start> "+ capt + " <end>"
valid_dataset.write((img+"\t"+caption+"\n").encode())
valid_dataset.flush()
valid_dataset.close()
# Here, we're using ResNet50 Model
from IPython.core.display import display, HTML
model = ResNet50(include_top=False,weights='imagenet',input_shape=(224,224,3),pooling='avg')
model.summary()
# process images to target size
def preprocess(img_path):
im = image.load_img(img_path, target_size=(224,224,3))
im = image.img_to_array(im) # (x, y, z)
im = np.expand_dims(im, axis=0) # (0, x, y, z)
return im
training_data = {}
counter=0
for item in x_training:
if item == "":
continue
if counter >= 3000:
break
counter+=1
if counter%1000==0:
print(counter)
path = img_path + item
img = preprocess(path) #to change the dimensions of the image for using ResNet model
pred = model.predict(img).reshape(2048) # shape of each image is (2048, 0)
training_data[item] = pred
# opening train_enc_img.p file and dumping content of training_data to this file
with open( "train_enc_img.p", "wb" ) as pickle_f: #obj hierarchy is converted into byte stream
pickle.dump(training_data, pickle_f )
# Storing image and its corresponding caption into a dataframe
pd_dataset = pd.read_csv("flickr_8k_train_dataset.txt", delimiter='\t')
dframe = pd_dataset.values
print(dframe.shape)
pd_dataset.head()
# Storing all the captions from dframe into a list
senten = []
for item in range(dframe.shape[0]):
senten.append(dframe[item, 1])
#senten will have 30000 length
# First 5 captions stored in senten
senten[:5]
# Splitting each captions stored in 'senten' and storing them in 'wor' as list of list
wor = [i.split() for i in senten]
# Creating a list of all unique wor
uniq = []
for i in wor:
uniq.extend(i)
uniq = list(set(uniq))
print(len(uniq))
vocabulary_size = len(uniq)
# making 2 lists to index each unique word and vice-versa
w_to_i = {val:index for index, val in enumerate(uniq)}
i_to_w = {index:val for index, val in enumerate(uniq)}
w_to_i['UNK'] = 0
w_to_i['raining'] = 8253
i_to_w[0] = 'UNK'
i_to_w[8253] = 'raining'
vocabulary_size = len(w_to_i.keys())
print(vocabulary_size)
max_len = 0
for i in senten:
i = i.split()
if len(i) > max_len:
max_len = len(i)
print(max_len) #finding longest caption
pad_seq, subsequent_wor = [], []
for item in range(dframe.shape[0]): #30000 items
part_seq = []
next_wor = []
text = dframe[item, 1].split() #diving each caption for every image into words
text = [w_to_i[i] for i in text] #finding index for each word
for i in range(1, len(text)):
part_seq.append(text[:i]) #start, 1st word, ... , last word
next_wor.append(text[i]) #1st word, ... , last word, end
pad_part_seq = sequence.pad_sequences(part_seq, max_len, padding='post')
next_wor_1hot = np.zeros([len(next_wor), vocabulary_size], dtype=np.bool)
for i,next_word in enumerate(next_wor):
next_wor_1hot[i, next_word] = 1
pad_seq.append(pad_part_seq )
subsequent_wor.append(next_wor_1hot)
pad_seq = np.asarray(pad_seq)
subsequent_wor = np.asarray(subsequent_wor)
print(pad_seq.shape)
print(subsequent_wor.shape)
print(pad_seq[0])
for item in range(len(pad_seq[0])):
for y in range(max_len):
print(i_to_w[pad_seq[0][item][y]],)
print("\n")
print(len(pad_seq[0]))
num_imgs = 2000
cap = np.zeros([0, max_len])
next_wor = np.zeros([0, vocabulary_size])
for item in range(num_imgs): #img_to_padded_seqs.shape[0]):
cap = np.concatenate([cap, pad_seq[item]])
next_wor = np.concatenate([next_wor, subsequent_wor[item]])
np.save("cap.npy", cap)
np.save("next_wor.npy", next_wor)
print(cap.shape)
print(next_wor.shape)
with open('train_enc_img.p', 'rb') as f:
enc_img = pickle.load(f, encoding="bytes")
imgs = []
for item in range(dframe.shape[0]): #30000
if dframe[item, 0] in enc_img.keys(): #dframe[0,0], [1,0], ... , [4,0] match with 0th key of enc_img
imgs.append(list(enc_img[dframe[item, 0]]))
imgs = np.asarray(imgs)
print(imgs.shape)
images = []
img_names = []
for item in range(num_imgs): #2000
for y in range(pad_seq[item].shape[0]): #14
images.append(imgs[item]) #1st iteration: 14 times name of image in byte form
img_names.append(dframe[item, 0]) # normal form
images = np.asarray(images) #images contains image_name in byte form
np.save("images.npy", images)
img_names = np.asarray(img_names) #img_names contains image_name normally
np.save("img_names.npy", img_names)
print(images.shape)
print(len(img_names))
cap = np.load("cap.npy")
next_wor = np.load("next_wor.npy")
print(cap.shape)
print(next_wor.shape)
images = np.load("images.npy")
print(images.shape)
imag = np.load("img_names.npy")
print(imag.shape)
embed_size = 128
max_len = 40
img_model = Sequential()
img_model.add(Dense(embed_size, input_shape=(2048,), activation='relu'))
img_model.add(RepeatVector(max_len))
img_model.summary()
lang_model = Sequential()
lang_model.add(Embedding(input_dim=vocabulary_size, output_dim=embed_size, input_length=max_len))
lang_model.add(LSTM(256, return_sequences=True))
lang_model.add(TimeDistributed(Dense(embed_size)))
lang_model.summary()
concat = Concatenate()([img_model.output, lang_model.output])
x = LSTM(128, return_sequences=True)(concat)
x = LSTM(512, return_sequences=False)(x)
x = Dense(vocabulary_size)(x)
out = Activation('softmax')(x)
model = Model(inputs=[img_model.input, lang_model.input], outputs = out)
model.compile(loss='categorical_crossentropy', optimizer='RMSprop', metrics=['accuracy'])
model.summary()
hist = model.fit([images, cap], next_wor, batch_size=512, epochs=210)
for label in ["loss"]:
plt.plot(hist.history[label],label=label)
plt.legend()
plt.xlabel("epochs")
plt.ylabel("loss")
plt.show()
for label in ["accuracy"]:
plt.plot(hist.history[label],label=label)
plt.legend()
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.show()
model.save_weights("model_weights.h5")
def preprocess(img_path):
im = image.load_img(img_path, target_size=(224,224,3))
im = image.img_to_array(im) #(224,224,3)
im = np.expand_dims(im, axis=0) #(1,224,224,3)
return im
def | get_encode | identifier_name |
|
idempotent.rs | // we always receive `[x, n] as a`
// ..
// (v-- chut' ne udalil :lol:, podumal wo hn9, A NE-NE-NE)
//> ... SO, if "fn" mutate own args, and computation which "generate new value,
// to update old value in args (in case of [] is some "next-empty-cell" in arr, and `len`)
// is based ON THIS ARG", ..
/// we (most likely) will consider it as NOT IDEMPONENT
/// .. SO .. WHAT IS IMPORTANT ??
// despite to be NOT IDEMPOTENT (from "caller" perspective) .. since we have
// 2 refs (caller and callee) and "our"(callee) is `mut` .. WE HAVE ADVANTAGE
// of EXPLICIT PASSING THIS REF(to callee) , BUT unfortunatly in JS we can't write
// `&mut reff` ..
// IT'S (1) PREVENT "ORDER"-PROBLEM described above (2) makes MORE OBVIOUS for
// "reviewer" that "a" can be mutated (he at least SEE this "a" is passsed) ..
// ..but `some_fn(num)` is MUCH WORSE
//
/// TRY TO MAKE ALL EFFECTFULL-FN TO BE IDEMPOTENT
|
1
// ALSO: (p.s. JS here, ONLY SINGLE-threaded programs and (in this post) SYNC)
{
fn calculateAverage(list) { // << obviously IDEMPOTENT
sum = list.reduce((sum, x) => x + sum, 0);
return sum / list.length;
}
var sum, nums = [1,2,4,7,11,16,22];
var avg = calculateAverage( nums );
}
// Getify said that (if `sum` not mutably-aliased some another closure)
// mutation of `sum` here it's "UNOBSERVED SIDE-EFF" ..
// (.. although, such "UNOBSERVED MUTATIONS" easy can be eliminated, and we can use
// pure-style easily here (but actually here it's just MATTER OF TASTE)
// )
// ... SO .. what reasons we have for IDEMPOTENT MUTATIONS aka "unobserved side-eff"?
// ... either NONE or "OWNED DATA"(P.Graham)
// .. and further author cite Hickey:
/// "If a tree falls in the forest, but no one is around to hear it, does it still make a sound?"
// (^-- NO SHARED MUTABLE ALIASING .. or ..
// .. we INCAPSULATE some data to MAINTAIN invariant [like in
// exmps/js_state.rs:state_shraing] )
//
// .. so it "like" pure-fn, or in term of P.Graham fn what used "owned data"
fn get_cached_fn() {
/// AS-OPPOSED to "`a` in `some_fn`"(above) `cache` is not "mut aliased"(only one ref which
/// mutate and read)
var cache = {}; // << "owned data", "unheard tree in the forest"
return fn XX(n) { // "unobserved mutation", "like-pure", "right incapsultaion"
if (cache[n] !== undefined) return cache[n] // .... NAZYVAI KAK HOCHEW'
..... /* do computation */ cache[n] = res_of_comutation();
}
} // author: "The point is that if XX(..) is the only part of the program that accesses
// and updates the cache side cause/effect, so it's "like"-pure"
|
2.0
// ALSO: ORDER/FREQUENCY DEPENDENCY
{
var users = {}, userOrders = {};
fn fetchUserData(userId) {
ajax( "http://some.api/user/" + userId, fn onUserData(userData) { | }
fn fetchOrders(userId) {
ajax( "http://some.api/orders/" + userId, fn onOrders(orders) {
for (let i = 0; i < orders.length; i++) {
// keep a reference to latest order for each user
users[userId].latestOrder = orders[i];
userOrders[orders[i].orderId] = orders[i];
}
});
}
}
// `fetchUserData` should be called before `fetchOrders` ... AVOID SUCH "LOCAL STATE MACHINES"
/// [GIST] there is should NOT BE ANY DEPENDENCY between ORDER/FREQUENCY OF CALL to
/// "getters/setters" ..(that is (kind of) SHOULD BE ONLY IDEMPOTENT-EFFECTFUL-FN)..
/// of some "local state machine" aka "class instance" aka "object"(with incapsulation)
// ..
// ...So.. in this exmp, (also Miwko: initializing DB, which depends on "glob-state" - that is
// "aliasing") .. `fetchOrders` depends on
///| to be called.. IN SOME PARTICULAR STATE .. and this state is reached through
///| "PARAMS-REF"(aliasing) ... SO.. in such case,
///| -=! SUCH STATE SHOULD BE PASSED DIRECTLY !=-..
/// (as in Miwko db-inital we refactor too)
/// ..to AVOID "ORDER/FREQUENCY-OF-CALL(getter/setter) DEPENDENCY"(to set "needed" state)
// ... any Getter/Setter should be designed in such way to BE ABLE to be called in ANY STATE!
//>> OR.. THIS "ORDER_DEPENDENCY/COUPLING" SHOULD BE INCAPSULATED IN fn
/// (BUT EXPLICIT PASSING OF MUT_ALISASED DEPENDENCY AS ARG
/// IF IT POSSIBLE
/// IS BETTER)
// (in Miwko db-exmp: if we don't pass explicitly "mut-aliased"-state , then we should
// incapsulate all COUPLED fns in single fn .. that is prepare NEEDED STATE ..
// BUT.. IF THIS CHAIN OF COUPLED-fns is too long ..
// |> WE RETURN TO THE PROBLEM ..
// since we refactoring of fn-that-incapsulate-coupling is ERROR PRONE .. SO
/// THIS CHAIN OF COUPLED_FNs SHOULD BE SHORT .. USUALLY === 2 )
// ..
// Of course to achieve some "desired side-effs"(without them programm is useless) we
// OFTEN need call "getters/setters" in some particular order ..BUT.. that DOESN'T mean that
// this order should become SPECIAL(HARDCODED) aka ORDER DEPENDENCY .. we just peek that order,
// but it's should NOT BE SPECIAL for our "get/set-ters".
//
| 2.1
// So.. why I looked at ::exmps/js_state.rs::state_sharing fn .. and though: "why I need
// "immutable-world", clojure, etc .. "ved'" this fn pretty good, and do its job well"
// ..
// .... BECAUSE: this "local-state-machine" don't rely on PARTICULAR STATE and ORDER/FREQUENCY..
// so IN ANY STATE ... we can call "get/set-ters" in ANY ORDER .. AND IT'S OK, IT DO EXACTLY
// WHAT WE WANT, EXECTLY SIDE-EFF WHAT WE WANT.
/// After createing an object we can start do ANY "STATE_TRANSITION" which this
/// object has, BUT, if only some STATE_TRANSITIONS allowed, IT'S ERRORPRONE.
// ...> whether "produce" or "consume" be called first .. WE DON'T CARE,
// ...> what the state we have in the moment of call to any fn(cons/prod) .. WE DON'T CARE...
// ..(some particular-state doesn't have special meaning for us)
// .....
///|"consume"(as a getter[but it aslo a setter]) is NOT IDEMPOTENT .. because..
// for this I need pass the list-for-consuming EXPLICITLY..
// (the main condition for IDEMPOTENCY - absence of MUT_ALIASING[here `list`])
/// .. BUT:
/// It INCAPSULATE "INVARIANT" of "prefiex is chenged only when we "splavili" old values in a
/// list and clean it up"
///>> .. INCUPSULATEs IN ONE STATE_TRANSITION
// .. SO .. it's let's both (`consume` and `produce`) "fns" works without FEAR about shared
// (between them ) STATE(and INCAPSULATED) on which the relie(mut_aliased) since it doesn't
// aliased elsewhere("tree in the wood") .. and PROPERLY changed (INVARIANT) in `consumer`, and
// this change INCAPSULATED in right place
/// that_is: WE DEFINE ATOMIC_STATE_TRANSITIONs, why atomic, since state mutation/transaction
/// can't be "interrupted" (here exmp: "prefix" changed BUT we not yet "splavili" values from
/// `list` -- IT'S INTERRUPTION of STATE_TRANSITION)
/// ..
// .. also .. | users[userId] = userData;
}); | random_line_split |
idempotent.rs |
// not IDEMPOTENT because: *WRONG: we update, and/but not completly rewrite `x`,
// *RIGHT: mut_aliasing (our computed value for `x` rely on mut_aliased `x`)
// (BUT)
// BTW(p.s.)--v: `some_fn` break rule:
/// "mutate only TREE_in_the_WOOD , emit "own_copied/immutabl" value"
// (TREE_in_the_WOOD is accesed or through "self/this", or "closure"-capturing)
//
fn some_fn(a = [], n) { a.push(n) }
// ^-- here was: "ADD value, not just change."
// BUT actually .. it's also can be considered as MUT_alising .. since result of `push`
// depends of `a`, .. and if we call 2 times `some_fn` of course it's gives different sideeff,
// since its computation based on MUTated value, ("EU ZHE")
// ..
// From the other hand .. `some_fn` can be considered as IDEMPONENT, since it's always gives
// the same side-eff for the same input-VALUE .. that is if we alway will give `[x] as a` ..
// we always receive `[x, n] as a`
// ..
// (v-- chut' ne udalil :lol:, podumal wo hn9, A NE-NE-NE)
//> ... SO, if "fn" mutate own args, and computation which "generate new value,
// to update old value in args (in case of [] is some "next-empty-cell" in arr, and `len`)
// is based ON THIS ARG", ..
/// we (most likely) will consider it as NOT IDEMPONENT
/// .. SO .. WHAT IS IMPORTANT ??
// despite to be NOT IDEMPOTENT (from "caller" perspective) .. since we have
// 2 refs (caller and callee) and "our"(callee) is `mut` .. WE HAVE ADVANTAGE
// of EXPLICIT PASSING THIS REF(to callee) , BUT unfortunatly in JS we can't write
// `&mut reff` ..
// IT'S (1) PREVENT "ORDER"-PROBLEM described above (2) makes MORE OBVIOUS for
// "reviewer" that "a" can be mutated (he at least SEE this "a" is passsed) ..
// ..but `some_fn(num)` is MUCH WORSE
//
/// TRY TO MAKE ALL EFFECTFULL-FN TO BE IDEMPOTENT
|
1
// ALSO: (p.s. JS here, ONLY SINGLE-threaded programs and (in this post) SYNC)
{
fn calculateAverage(list) { // << obviously IDEMPOTENT
sum = list.reduce((sum, x) => x + sum, 0);
return sum / list.length;
}
var sum, nums = [1,2,4,7,11,16,22];
var avg = calculateAverage( nums );
}
// Getify said that (if `sum` not mutably-aliased some another closure)
// mutation of `sum` here it's "UNOBSERVED SIDE-EFF" ..
// (.. although, such "UNOBSERVED MUTATIONS" easy can be eliminated, and we can use
// pure-style easily here (but actually here it's just MATTER OF TASTE)
// )
// ... SO .. what reasons we have for IDEMPOTENT MUTATIONS aka "unobserved side-eff"?
// ... either NONE or "OWNED DATA"(P.Graham)
// .. and further author cite Hickey:
/// "If a tree falls in the forest, but no one is around to hear it, does it still make a sound?"
// (^-- NO SHARED MUTABLE ALIASING .. or ..
// .. we INCAPSULATE some data to MAINTAIN invariant [like in
// exmps/js_state.rs:state_shraing] )
//
// .. so it "like" pure-fn, or in term of P.Graham fn what used "owned data"
fn get_cached_fn() {
/// AS-OPPOSED to "`a` in `some_fn`"(above) `cache` is not "mut aliased"(only one ref which
/// mutate and read)
var cache = {}; // << "owned data", "unheard tree in the forest"
return fn XX(n) { // "unobserved mutation", "like-pure", "right incapsultaion"
if (cache[n] !== undefined) return cache[n] // .... NAZYVAI KAK HOCHEW'
..... /* do computation */ cache[n] = res_of_comutation();
}
} // author: "The point is that if XX(..) is the only part of the program that accesses
// and updates the cache side cause/effect, so it's "like"-pure"
|
2.0
// ALSO: ORDER/FREQUENCY DEPENDENCY
{
var users = {}, userOrders = {};
fn fetchUserData(userId) {
ajax( "http://some.api/user/" + userId, fn onUserData(userData) {
users[userId] = userData;
});
}
fn fetchOrders(userId) {
ajax( "http://some.api/orders/" + userId, fn onOrders(orders) {
for (let i = 0; i < orders.length; i++) {
// keep a reference to latest order for each user
users[userId].latestOrder = orders[i];
userOrders[orders[i].orderId] = orders[i];
}
});
}
}
// `fetchUserData` should be called before `fetchOrders` ... AVOID SUCH "LOCAL STATE MACHINES"
/// [GIST] there is should NOT BE ANY DEPENDENCY between ORDER/FREQUENCY OF CALL to
/// "getters/setters" ..(that is (kind of) SHOULD BE ONLY IDEMPOTENT-EFFECTFUL-FN)..
/// of some "local state machine" aka "class instance" aka "object"(with incapsulation)
// ..
// ...So.. in this exmp, (also Miwko: initializing DB, which depends on "glob-state" - that is
// "aliasing") .. `fetchOrders` depends on
///| to be called.. IN SOME PARTICULAR STATE .. and this state is reached through
///| "PARAMS-REF"(aliasing) ... SO.. in such case,
///| -=! SUCH STATE SHOULD BE PASSED DIRECTLY !=-..
/// (as in Miwko db-inital we refactor too)
/// ..to AVOID "ORDER/FREQUENCY-OF-CALL(getter/setter) DEPENDENCY"(to set "needed" state)
// ... any Getter/Setter should be designed in such way to BE ABLE to be called in ANY STATE!
//>> OR.. THIS "ORDER_DEPENDENCY/COUPLING" SHOULD BE INCAPSULATED IN fn
/// (BUT EXPLICIT PASSING OF MUT_ALISASED DEPENDENCY AS ARG
/// IF IT POSSIBLE
/// IS BETTER)
// (in Miwko db-exmp: if we don't pass explicitly "mut-aliased"-state , then we should
// incapsulate all COUPLED fns in single fn .. that is prepare NEEDED STATE ..
// BUT.. IF THIS CHAIN OF COUPLED-fns is too long ..
// |> WE RETURN TO THE PROBLEM ..
// since we refactoring of fn-that-incapsulate-coupling is ERROR PRONE .. SO
/// THIS CHAIN OF COUPLED_FNs SHOULD BE SHORT .. USUALLY === 2 )
// ..
// Of course to achieve some "desired side-effs"(without them programm is useless) we
// OFTEN need call "getters/setters" in some particular order ..BUT.. that DOESN'T mean that
// this order should become SPECIAL(HARDCODED) aka ORDER DEPENDENCY .. we just peek that order,
// but it's should NOT BE SPECIAL for our "get/set-ters".
//
| 2.1
// So.. why I looked at ::exmps/js_state.rs::state_sharing fn .. and though: "why I need
// "immutable-world", clojure, etc .. "ved'" this fn pretty good, and do its job well"
// ..
// .... BECAUSE: this "local-state-machine" don't rely on PARTICULAR STATE and ORDER/FREQUENCY..
// so IN ANY STATE ... we can call "get/set-ters" in ANY ORDER .. AND IT'S OK, IT DO EXACTLY
// WHAT WE WANT, EXECTLY SIDE-EFF WHAT WE WANT.
/// After createing an object we can start do ANY "STATE_TRANSITION" which this
/// object has, BUT, if only some STATE_TRANSITIONS allowed, IT'S ERRORPRONE.
// ...> whether "produce" or "consume" be called first .. WE DON'T CARE,
// ...> what the state we have in the moment of call to any fn(cons/prod) .. WE DON'T CARE...
// ..(some particular-state doesn't have special meaning for us)
// .....
///|"consume"(as a getter[but it aslo | { x += n*x } | identifier_body |
|
idempotent.rs | (a = [], n) { a.push(n) }
// ^-- here was: "ADD value, not just change."
// BUT actually .. it's also can be considered as MUT_alising .. since result of `push`
// depends of `a`, .. and if we call 2 times `some_fn` of course it's gives different sideeff,
// since its computation based on MUTated value, ("EU ZHE")
// ..
// From the other hand .. `some_fn` can be considered as IDEMPONENT, since it's always gives
// the same side-eff for the same input-VALUE .. that is if we alway will give `[x] as a` ..
// we always receive `[x, n] as a`
// ..
// (v-- chut' ne udalil :lol:, podumal wo hn9, A NE-NE-NE)
//> ... SO, if "fn" mutate own args, and computation which "generate new value,
// to update old value in args (in case of [] is some "next-empty-cell" in arr, and `len`)
// is based ON THIS ARG", ..
/// we (most likely) will consider it as NOT IDEMPONENT
/// .. SO .. WHAT IS IMPORTANT ??
// despite to be NOT IDEMPOTENT (from "caller" perspective) .. since we have
// 2 refs (caller and callee) and "our"(callee) is `mut` .. WE HAVE ADVANTAGE
// of EXPLICIT PASSING THIS REF(to callee) , BUT unfortunatly in JS we can't write
// `&mut reff` ..
// IT'S (1) PREVENT "ORDER"-PROBLEM described above (2) makes MORE OBVIOUS for
// "reviewer" that "a" can be mutated (he at least SEE this "a" is passsed) ..
// ..but `some_fn(num)` is MUCH WORSE
//
/// TRY TO MAKE ALL EFFECTFULL-FN TO BE IDEMPOTENT
|
1
// ALSO: (p.s. JS here, ONLY SINGLE-threaded programs and (in this post) SYNC)
{
fn calculateAverage(list) { // << obviously IDEMPOTENT
sum = list.reduce((sum, x) => x + sum, 0);
return sum / list.length;
}
var sum, nums = [1,2,4,7,11,16,22];
var avg = calculateAverage( nums );
}
// Getify said that (if `sum` not mutably-aliased some another closure)
// mutation of `sum` here it's "UNOBSERVED SIDE-EFF" ..
// (.. although, such "UNOBSERVED MUTATIONS" easy can be eliminated, and we can use
// pure-style easily here (but actually here it's just MATTER OF TASTE)
// )
// ... SO .. what reasons we have for IDEMPOTENT MUTATIONS aka "unobserved side-eff"?
// ... either NONE or "OWNED DATA"(P.Graham)
// .. and further author cite Hickey:
/// "If a tree falls in the forest, but no one is around to hear it, does it still make a sound?"
// (^-- NO SHARED MUTABLE ALIASING .. or ..
// .. we INCAPSULATE some data to MAINTAIN invariant [like in
// exmps/js_state.rs:state_shraing] )
//
// .. so it "like" pure-fn, or in term of P.Graham fn what used "owned data"
fn get_cached_fn() {
/// AS-OPPOSED to "`a` in `some_fn`"(above) `cache` is not "mut aliased"(only one ref which
/// mutate and read)
var cache = {}; // << "owned data", "unheard tree in the forest"
return fn XX(n) { // "unobserved mutation", "like-pure", "right incapsultaion"
if (cache[n] !== undefined) return cache[n] // .... NAZYVAI KAK HOCHEW'
..... /* do computation */ cache[n] = res_of_comutation();
}
} // author: "The point is that if XX(..) is the only part of the program that accesses
// and updates the cache side cause/effect, so it's "like"-pure"
|
2.0
// ALSO: ORDER/FREQUENCY DEPENDENCY
{
var users = {}, userOrders = {};
fn fetchUserData(userId) {
ajax( "http://some.api/user/" + userId, fn onUserData(userData) {
users[userId] = userData;
});
}
fn fetchOrders(userId) {
ajax( "http://some.api/orders/" + userId, fn onOrders(orders) {
for (let i = 0; i < orders.length; i++) {
// keep a reference to latest order for each user
users[userId].latestOrder = orders[i];
userOrders[orders[i].orderId] = orders[i];
}
});
}
}
// `fetchUserData` should be called before `fetchOrders` ... AVOID SUCH "LOCAL STATE MACHINES"
/// [GIST] there is should NOT BE ANY DEPENDENCY between ORDER/FREQUENCY OF CALL to
/// "getters/setters" ..(that is (kind of) SHOULD BE ONLY IDEMPOTENT-EFFECTFUL-FN)..
/// of some "local state machine" aka "class instance" aka "object"(with incapsulation)
// ..
// ...So.. in this exmp, (also Miwko: initializing DB, which depends on "glob-state" - that is
// "aliasing") .. `fetchOrders` depends on
///| to be called.. IN SOME PARTICULAR STATE .. and this state is reached through
///| "PARAMS-REF"(aliasing) ... SO.. in such case,
///| -=! SUCH STATE SHOULD BE PASSED DIRECTLY !=-..
/// (as in Miwko db-inital we refactor too)
/// ..to AVOID "ORDER/FREQUENCY-OF-CALL(getter/setter) DEPENDENCY"(to set "needed" state)
// ... any Getter/Setter should be designed in such way to BE ABLE to be called in ANY STATE!
//>> OR.. THIS "ORDER_DEPENDENCY/COUPLING" SHOULD BE INCAPSULATED IN fn
/// (BUT EXPLICIT PASSING OF MUT_ALISASED DEPENDENCY AS ARG
/// IF IT POSSIBLE
/// IS BETTER)
// (in Miwko db-exmp: if we don't pass explicitly "mut-aliased"-state , then we should
// incapsulate all COUPLED fns in single fn .. that is prepare NEEDED STATE ..
// BUT.. IF THIS CHAIN OF COUPLED-fns is too long ..
// |> WE RETURN TO THE PROBLEM ..
// since we refactoring of fn-that-incapsulate-coupling is ERROR PRONE .. SO
/// THIS CHAIN OF COUPLED_FNs SHOULD BE SHORT .. USUALLY === 2 )
// ..
// Of course to achieve some "desired side-effs"(without them programm is useless) we
// OFTEN need call "getters/setters" in some particular order ..BUT.. that DOESN'T mean that
// this order should become SPECIAL(HARDCODED) aka ORDER DEPENDENCY .. we just peek that order,
// but it's should NOT BE SPECIAL for our "get/set-ters".
//
| 2.1
// So.. why I looked at ::exmps/js_state.rs::state_sharing fn .. and though: "why I need
// "immutable-world", clojure, etc .. "ved'" this fn pretty good, and do its job well"
// ..
// .... BECAUSE: this "local-state-machine" don't rely on PARTICULAR STATE and ORDER/FREQUENCY..
// so IN ANY STATE ... we can call "get/set-ters" in ANY ORDER .. AND IT'S OK, IT DO EXACTLY
// WHAT WE WANT, EXECTLY SIDE-EFF WHAT WE WANT.
/// After createing an object we can start do ANY "STATE_TRANSITION" which this
/// object has, BUT, if only some STATE_TRANSITIONS allowed, IT'S ERRORPRONE.
// ...> whether "produce" or "consume" be called first .. WE DON'T CARE,
// ...> what the state we have in the moment of call to any fn(cons/prod) .. WE DON'T CARE...
// ..(some particular-state doesn't have special meaning for us)
// .....
///|"consume"(as a getter[but it aslo a setter]) is NOT IDEMPOTENT .. because..
// for this I need pass the list-for-consuming EXPLICITLY..
// (the main condition for IDEMPOTENCY - absence of MUT_ALIASING[here `list`])
/// .. BUT:
/// It INCAPSULATE "INVARIANT" of "prefiex is chenged only when we "splavili" old values in a
/// list and clean it up"
///>> .. INCUPSULATEs IN ONE STATE_TRANSITION
// .. SO .. it's let's both (`consume` and `produce`) "fns" | some_fn | identifier_name |
|
core_convert.py | # TODO: MAP THIS ?: 4, # Grekiskt
# TODO: MAP THIS ?: 5, # Indien
# TODO: MAP THIS ?: 6, # Nordamerika
# TODO: MAP THIS ?: 7, # Latinamerika
# TODO: MAP THIS ?: 8, # Orienten
# TODO: MAP THIS ?: 9, # Japan
# TODO: MAP THIS ?: 10, # Italienskt
# TODO: MAP THIS ?: 11, # Sydostasien
# TODO: MAP THIS ?: 12, # Spansk
# TODO: MAP THIS ?: 13, # Tyskland
# TODO: MAP THIS ?: 14, # "Ryssland och Östeuropa"
# TODO: MAP THIS ?: 15, # Internationellt
# TODO: MAP THIS ?: 16, # Övriga
# TODO: MAP THIS ?: 73, # Sverige
# TODO: MAP THIS ?: 74, # Norge
# TODO: MAP THIS ?: 75, # Kanada
# TODO: MAP THIS ?: 76, # Frankrike
# TODO: MAP THIS ?: 77, # Grekland
# TODO: MAP THIS ?: 78, # Portugal
# TODO: MAP THIS ?: 79, # Danmark
# TODO: MAP THIS ?: 80, # Italien
# TODO: MAP THIS ?: 81, # Finland
# TODO: MAP THIS ?: 82, # Kalifornien
# TODO: MAP THIS ?: 83, # Thailand
# TODO: MAP THIS ?: 84, # Kina
# TODO: MAP THIS ?: 85, # Belgien
# TODO: MAP THIS ?: 86, # Europa
# TODO: MAP THIS ?: 87, # Turkiet
# TODO: MAP THIS ?: 88, # Holland
# TODO: MAP THIS ?: 89, # England
# TODO: MAP THIS ?: 90, # Spanien
# TODO: MAP THIS ?: 91, # Nederländerna
# TODO: MAP THIS ?: 92, # Polen
# TODO: MAP THIS ?: 93, # "Blandat: EG och icke EG"
# TODO: MAP THIS ?: 94, # Ungern
# TODO: MAP THIS ?: 95, # Bulgarien
# TODO: MAP THIS ?: 96, # Kroatien
# TODO: MAP THIS ?: 98, # India
# TODO: MAP THIS ?: 99, # Uruguay
# TODO: MAP THIS ?: 100, # Irland
# TODO: MAP THIS ?: 101, # "Nya Zeeland"
# TODO: MAP THIS ?: 102, # Sverige/England
# TODO: MAP THIS ?: 103, # Sverige/Danmark
# TODO: MAP THIS ?: 104, # China
# TODO: MAP THIS ?: 105, # Holland/Frankrike
# TODO: MAP THIS ?: 106, # "Costa Rica"
# TODO: MAP THIS ?: 107, # Zaire
# TODO: MAP THIS ?: 108, # Israel/USA
# TODO: MAP THIS ?: 109, # Mexico
# TODO: MAP THIS ?: 110, # Holland/Belgien
# TODO: MAP THIS ?: 111, # Frankrike/Italien
# TODO: MAP THIS ?: 112, # Sverge
# TODO: MAP THIS ?: 113, # Centralamerika
# TODO: MAP THIS ?: 114, # Brasilien
# TODO: MAP THIS ?: 115, # Israel/Indien
# TODO: MAP THIS ?: 116, # "Italien/Nya Zeeland"
# TODO: MAP THIS ?: 117, # Sydafrika
# TODO: MAP THIS ?: 118, # Argentina
# TODO: MAP THIS ?: 119, # China/Thailand
# TODO: MAP THIS ?: 120, # USA
# TODO: MAP THIS ?: 121, # Kenya
# TODO: MAP THIS ?: 122, # Israel
# TODO: MAP THIS ?: 123, # Malaysia
# TODO: MAP THIS ?: 124, # Nordostatlanten
# TODO: MAP THIS ?: 125, # Vietnam
# TODO: MAP THIS ?: 126, # Norden
# TODO: MAP THIS ?: 127, # Litauen
# TODO: MAP THIS ?: 131, # Roslagen
# TODO: MAP THIS ?: 135, # U.S.A.
# TODO: MAP THIS ?: 136, # DK
# TODO: MAP THIS ?: 137, # Egypten
# TODO: MAP THIS ?: 138, # Marocko
# TODO: MAP THIS ?: 139, # Chile
# TODO: MAP THIS ?: 140, # "Dominikanska Republiken"
# TODO: MAP THIS ?: 141, # Iran
# TODO: MAP THIS ?: 142, # Colombia
# TODO: MAP THIS ?: 143, # Peru
# TODO: MAP THIS ?: 144, # Zimbabwe
}
return table[key] if key in table else None
def convert_attributes(product, detail=None):
result = []
for tag in product.tags.all():
id = get_attribute_id(tag.name)
if id is not None:
result.append({
'AttributeId': id
})
# Special case for "Nyhet"
if not detail and product.product_detail:
detail = product.product_detail.filter(store=10).first()
if detail is None:
detail = product.product_detail.first()
if detail:
first_enabled = detail.first_enabled if detail.first_enabled else datetime.now() - \
timedelta(days=60)
result.append({
'AttributeId': 2173,
'FromDate': first_enabled,
'ToDate': first_enabled + timedelta(days=30),
})
return result
def create_dynamic_property(key, value, store=None):
prop = {
'PropertyId': get_dynamic_property_id(key),
'PropertyName': key,
'PropertyValue': value,
}
if store is not None:
prop['StoreId'] = store
return prop
def convert_dynamic_properties(product):
result = [
create_dynamic_property('Volume', product.volume_dm3),
create_dynamic_property('Weight', product.weight_g),
create_dynamic_property('KfpHeightMM', product.height_mm),
create_dynamic_property('KfpLengthtMM', product.length_mm),
create_dynamic_property('KfpWidthMM', product.width_mm),
create_dynamic_property('Season', '.'.join(
convert_season_tags(product))),
create_dynamic_property('LastReceiptDay', product.last_receipt_day),
create_dynamic_property('LastSalesDay', product.last_sales_day),
create_dynamic_property('TruckrouteOptimizationProd3',
convert_order_route_from_product_type(product.product_type)),
create_dynamic_property('BDMaterialNumber',
product.prefered_merchantarticle.external_id if product.prefered_merchantarticle else None),
create_dynamic_property('SupplierArticleNumber',
product.prefered_merchantarticle.external_id if product.prefered_merchantarticle else None),
]
base_unit_quantity = get_base_unit_quantity(product, product.article.gtin)
if base_unit_quantity is not None:
create_dynamic_property('KfpDfp', base_unit_quantity)
for detail in product.product_detail.all():
result.append(create_dynamic_property(
'OrderFactor', 1 if detail.orderfactor else 0, detail.store))
result.append(create_dynamic_property(
'BDMaterialNumber', detail.prefered_merchantarticle.external_id if detail.prefered_merchantarticle else None, detail.store))
result.append(create_dynamic_property(
'SupplierArticleNumber', detail.prefered_merchantarticle.external_id if detail.prefered_merchantarticle else None, detail.store))
base_unit_quantity = get_base_unit_quantity(
detail, product.article.gtin)
if base_unit_quantity is not None:
create_dynamic_property('KfpDfp', base_unit_quantity, detail.store)
return result
def get_base_unit_quantity(product, base_unit_gtin):
if product.prefered_merchantarticle is not None:
if product.prefered_merchantarticle.article.child_gtin == base_unit_gtin:
return product.prefered_merchantarticle.article.quantity_of_lower_layer
else:
upper_quantity = product.prefered_merchantarticle.article.quantity_of_lower_layer
next_lower_article = Article.objects.filter(
gtin=product.prefered_merchantarticle.article.child_gtin).first()
if next_lower_article is not None:
if next_lower_article.child_gtin | == product.article.gtin:
return next_lower_article.quantity_of_lower_layer * upper_quantity
return None
def convert_u | conditional_block |
|
core_convert.py | '5+ dagar': 2197,
'7+ dagar': 2200,
'10+ dagar': 2203,
'30+ dagar': 2206,
'Svenskt ursprung': 2209,
'Svensk fågel': 2212,
'4+ dagar': 2215,
'Vegansk': 2218,
'MSC': 2219,
'Strategisk produkt': 2222,
'Svenskt sigill klimatcertifierad': 2224,
'ASC': 2227,
'Från Sverige': 2230,
'Kött från Sverige': 2233,
'Mjölk från Sverige': 2236,
'Faroklass brandfarligt': 2239,
'Faroklass miljöfarligt': 2242,
'Faroklass skadligt': 2245,
'Faroklass Warning': 2248,
'Energiklass A+': 2251,
'Energiklass C': 2254,
'Energiklass D': 2257,
'Energiklass E': 2260,
'Energiklass A++': 2263,
'Energiklass A': 2266,
'Energiklass B': 2269,
}
return table[key] if key in table else None
def get_dynamic_property_id
(key):
table = {
'Volume': 1,
'Weight': 2,
'KfpDfp': 3,
'LastSalesDay': 4,
'LastReceiptDay': 5,
'OldPz1': 6,
'OldPz2': 7,
'OldPz3': 8,
'MaxStock': 9,
'Season': 10,
'OrderFactor': 11,
'MinStock': 12,
'DfpLengthMM': 13,
'DfpWidthMM': 14,
'DfpHeightMM': 15,
'DfpWeightG': 16,
'DfpType': 17,
'SupplierArticleNumber': 18,
'AxfoodArticleId': 19,
'TruckrouteOptimizationProd3': 20,
'KfpHeightMM': 21,
'KfpLengthtMM': 22,
'KfpWidthMM': 23,
'IsFakeStockBalance': 24,
'ExternalImageUrl': 25,
'ProductSupplier': 26,
'ValdioDFPWidthMM': 27,
'ValdioDFPHeightMM': 28,
'ValidoDFPLengthtMM': 29,
'ValdioDFPWeightG': 30,
'DFPEANCode': 31,
'SafetyStock': 33,
'KfpDfpPurchaseOrder': 36,
'NoNutritionsNeeded': 38,
'NoIngredientsNeeded': 41,
'NoAllergensNeeded': 44,
'DeliveredUnitConversionFactor': 45,
'HandlingUnitQuantity': 46,
'BDMaterialNumber': 49,
'ProductSegment': 55,
'StandardUnitKfp': 56,
'StandardUnitGtin': 59,
'LimitedOfferProduct': 61,
'QLPricing': 64,
'QLMatching': 67,
'FirstSalesDate': 70,
'CategoryManager': 73,
}
return table[key] if key in table else None
def get_origin_id(key):
table = {
752: 1, # Svensk
249: 2, # Fransk
# TODO: MAP THIS ?: 3, # Afrika
# TODO: MAP THIS ?: 4, # Grekiskt
# TODO: MAP THIS ?: 5, # Indien
# TODO: MAP THIS ?: 6, # Nordamerika
# TODO: MAP THIS ?: 7, # Latinamerika
# TODO: MAP THIS ?: 8, # Orienten
# TODO: MAP THIS ?: 9, # Japan
# TODO: MAP THIS ?: 10, # Italienskt
# TODO: MAP THIS ?: 11, # Sydostasien
# TODO: MAP THIS ?: 12, # Spansk
# TODO: MAP THIS ?: 13, # Tyskland
# TODO: MAP THIS ?: 14, # "Ryssland och Östeuropa"
# TODO: MAP THIS ?: 15, # Internationellt
# TODO: MAP THIS ?: 16, # Övriga
# TODO: MAP THIS ?: 73, # Sverige
# TODO: MAP THIS ?: 74, # Norge
# TODO: MAP THIS ?: 75, # Kanada
# TODO: MAP THIS ?: 76, # Frankrike
# TODO: MAP THIS ?: 77, # Grekland
# TODO: MAP THIS ?: 78, # Portugal
# TODO: MAP THIS ?: 79, # Danmark
# TODO: MAP THIS ?: 80, # Italien
# TODO: MAP THIS ?: 81, # Finland
# TODO: MAP THIS ?: 82, # Kalifornien
# TODO: MAP THIS ?: 83, # Thailand
# TODO: MAP THIS ?: 84, # Kina
# TODO: MAP THIS ?: 85, # Belgien
# TODO: MAP THIS ?: 86, # Europa
# TODO: MAP THIS ?: 87, # Turkiet
# TODO: MAP THIS ?: 88, # Holland
# TODO: MAP THIS ?: 89, # England
# TODO: MAP THIS ?: 90, # Spanien
# TODO: MAP THIS ?: 91, # Nederländerna
# TODO: MAP THIS ?: 92, # Polen
# TODO: MAP THIS ?: 93, # "Blandat: EG och icke EG"
# TODO: MAP THIS ?: 94, # Ungern
# TODO: MAP THIS ?: 95, # Bulgarien
# TODO: MAP THIS ?: 96, # Kroatien
# TODO: MAP THIS ?: 98, # India
# TODO: MAP THIS ?: 99, # Uruguay
# TODO: MAP THIS ?: 100, # Irland
# TODO: MAP THIS ?: 101, # "Nya Zeeland"
# TODO: MAP THIS ?: 102, # Sverige/England
# TODO: MAP THIS ?: 103, # Sverige/Danmark
# TODO: MAP THIS ?: 104, # China
# TODO: MAP THIS ?: 105, # Holland/Frankrike
# TODO: MAP THIS ?: 106, # "Costa Rica"
# TODO: MAP THIS ?: 107, # Zaire
# TODO: MAP THIS ?: 108, # Israel/USA
# TODO: MAP THIS ?: 109, # Mexico
# TODO: MAP THIS ?: 110, # Holland/Belgien
# TODO: MAP THIS ?: 111, # Frankrike/Italien
# TODO: MAP THIS ?: 112, # Sver | 'Ekonomipack': 1,
'Nyckelhålsmärkt': 1736,
'Ekologisk': 2167,
'Glutenfri': 2168,
'Laktosfri': 2169,
'Låglaktos': 2170,
'Premiumkvalité': 2171,
'Mjölkproteinfri': 2172,
# 'Nyhet': 2173,
'18Åldersgräns': 2174,
'Fairtrade': 2175,
'Svanenmärkt': 2176,
'Kravmärkt': 2177,
'Video': 2178,
'Äkta vara': 2181,
'Astma- och Allergiförbundet': 2184,
'test': 2187,
'Rosa bandet': 2190,
'Svenskt sigill': 2191,
'3+ dagar': 2194, | identifier_body |
|
core_convert.py | : MAP THIS ?: 10, # Italienskt
# TODO: MAP THIS ?: 11, # Sydostasien
# TODO: MAP THIS ?: 12, # Spansk
# TODO: MAP THIS ?: 13, # Tyskland
# TODO: MAP THIS ?: 14, # "Ryssland och Östeuropa"
# TODO: MAP THIS ?: 15, # Internationellt
# TODO: MAP THIS ?: 16, # Övriga
# TODO: MAP THIS ?: 73, # Sverige
# TODO: MAP THIS ?: 74, # Norge
# TODO: MAP THIS ?: 75, # Kanada
# TODO: MAP THIS ?: 76, # Frankrike
# TODO: MAP THIS ?: 77, # Grekland
# TODO: MAP THIS ?: 78, # Portugal
# TODO: MAP THIS ?: 79, # Danmark
# TODO: MAP THIS ?: 80, # Italien
# TODO: MAP THIS ?: 81, # Finland
# TODO: MAP THIS ?: 82, # Kalifornien
# TODO: MAP THIS ?: 83, # Thailand
# TODO: MAP THIS ?: 84, # Kina
# TODO: MAP THIS ?: 85, # Belgien
# TODO: MAP THIS ?: 86, # Europa
# TODO: MAP THIS ?: 87, # Turkiet
# TODO: MAP THIS ?: 88, # Holland
# TODO: MAP THIS ?: 89, # England
# TODO: MAP THIS ?: 90, # Spanien
# TODO: MAP THIS ?: 91, # Nederländerna
# TODO: MAP THIS ?: 92, # Polen
# TODO: MAP THIS ?: 93, # "Blandat: EG och icke EG"
# TODO: MAP THIS ?: 94, # Ungern
# TODO: MAP THIS ?: 95, # Bulgarien
# TODO: MAP THIS ?: 96, # Kroatien
# TODO: MAP THIS ?: 98, # India
# TODO: MAP THIS ?: 99, # Uruguay
# TODO: MAP THIS ?: 100, # Irland
# TODO: MAP THIS ?: 101, # "Nya Zeeland"
# TODO: MAP THIS ?: 102, # Sverige/England
# TODO: MAP THIS ?: 103, # Sverige/Danmark
# TODO: MAP THIS ?: 104, # China
# TODO: MAP THIS ?: 105, # Holland/Frankrike
# TODO: MAP THIS ?: 106, # "Costa Rica"
# TODO: MAP THIS ?: 107, # Zaire
# TODO: MAP THIS ?: 108, # Israel/USA
# TODO: MAP THIS ?: 109, # Mexico
# TODO: MAP THIS ?: 110, # Holland/Belgien
# TODO: MAP THIS ?: 111, # Frankrike/Italien
# TODO: MAP THIS ?: 112, # Sverge
# TODO: MAP THIS ?: 113, # Centralamerika
# TODO: MAP THIS ?: 114, # Brasilien
# TODO: MAP THIS ?: 115, # Israel/Indien
# TODO: MAP THIS ?: 116, # "Italien/Nya Zeeland"
# TODO: MAP THIS ?: 117, # Sydafrika
# TODO: MAP THIS ?: 118, # Argentina
# TODO: MAP THIS ?: 119, # China/Thailand
# TODO: MAP THIS ?: 120, # USA
# TODO: MAP THIS ?: 121, # Kenya
# TODO: MAP THIS ?: 122, # Israel
# TODO: MAP THIS ?: 123, # Malaysia
# TODO: MAP THIS ?: 124, # Nordostatlanten
# TODO: MAP THIS ?: 125, # Vietnam
# TODO: MAP THIS ?: 126, # Norden
# TODO: MAP THIS ?: 127, # Litauen
# TODO: MAP THIS ?: 131, # Roslagen
# TODO: MAP THIS ?: 135, # U.S.A.
# TODO: MAP THIS ?: 136, # DK
# TODO: MAP THIS ?: 137, # Egypten
# TODO: MAP THIS ?: 138, # Marocko
# TODO: MAP THIS ?: 139, # Chile
# TODO: MAP THIS ?: 140, # "Dominikanska Republiken"
# TODO: MAP THIS ?: 141, # Iran
# TODO: MAP THIS ?: 142, # Colombia
# TODO: MAP THIS ?: 143, # Peru
# TODO: MAP THIS ?: 144, # Zimbabwe
}
return table[key] if key in table else None
def convert_attributes(product, detail=None):
result = []
for tag in product.tags.all():
id = get_attribute_id(tag.name)
if id is not None:
result.append({
'AttributeId': id
})
# Special case for "Nyhet"
if not detail and product.product_detail:
detail = product.product_detail.filter(store=10).first()
if detail is None:
detail = product.product_detail.first()
if detail:
first_enabled = detail.first_enabled if detail.first_enabled else datetime.now() - \
timedelta(days=60)
result.append({
'AttributeId': 2173,
'FromDate': first_enabled,
'ToDate': first_enabled + timedelta(days=30),
})
return result
def create_dynamic_property(key, value, store=None):
prop = {
'PropertyId': get_dynamic_property_id(key),
'PropertyName': key,
'PropertyValue': value,
}
if store is not None:
prop['StoreId'] = store
return prop
def convert_dynamic_properties(product):
result = [
create_dynamic_property('Volume', product.volume_dm3),
create_dynamic_property('Weight', product.weight_g),
create_dynamic_property('KfpHeightMM', product.height_mm),
create_dynamic_property('KfpLengthtMM', product.length_mm),
create_dynamic_property('KfpWidthMM', product.width_mm),
create_dynamic_property('Season', '.'.join(
convert_season_tags(product))),
create_dynamic_property('LastReceiptDay', product.last_receipt_day),
create_dynamic_property('LastSalesDay', product.last_sales_day),
create_dynamic_property('TruckrouteOptimizationProd3',
convert_order_route_from_product_type(product.product_type)),
create_dynamic_property('BDMaterialNumber',
product.prefered_merchantarticle.external_id if product.prefered_merchantarticle else None),
create_dynamic_property('SupplierArticleNumber',
product.prefered_merchantarticle.external_id if product.prefered_merchantarticle else None),
]
base_unit_quantity = get_base_unit_quantity(product, product.article.gtin)
if base_unit_quantity is not None:
create_dynamic_property('KfpDfp', base_unit_quantity)
for detail in product.product_detail.all():
result.append(create_dynamic_property(
'OrderFactor', 1 if detail.orderfactor else 0, detail.store))
result.append(create_dynamic_property(
'BDMaterialNumber', detail.prefered_merchantarticle.external_id if detail.prefered_merchantarticle else None, detail.store))
result.append(create_dynamic_property(
'SupplierArticleNumber', detail.prefered_merchantarticle.external_id if detail.prefered_merchantarticle else None, detail.store))
base_unit_quantity = get_base_unit_quantity(
detail, product.article.gtin)
if base_unit_quantity is not None:
create_dynamic_property('KfpDfp', base_unit_quantity, detail.store)
return result
def get_base_unit_quantity(product, base_unit_gtin):
if product.prefered_merchantarticle is not None:
if product.prefered_merchantarticle.article.child_gtin == base_unit_gtin:
return product.prefered_merchantarticle.article.quantity_of_lower_layer
else:
upper_quantity = product.prefered_merchantarticle.article.quantity_of_lower_layer
next_lower_article = Article.objects.filter(
gtin=product.prefered_merchantarticle.article.child_gtin).first()
if next_lower_article is not None:
if next_lower_article.child_gtin == product.article.gtin:
return next_lower_article.quantity_of_lower_layer * upper_quantity
return None
def convert_unit(validoo_unit):
# data from prefilledautomaten.unit
unit_table = { | "H87": 1, # st, PIECES
"GRM": 2, # g, WEIGHT
"KGM": 3, # kg, WEIGHT
"DLT": 6, # dl, VOLUME
"LTR": 7, # L, VOLUME | random_line_split |
|
core_convert.py | able = {
"Crossdocking": "X",
"Nightorder": "A",
}
return table[key] if key in table else None
def get_attribute_id(key):
# data from prefilledautomaten.attribute
table = {
'Ekonomipack': 1,
'Nyckelhålsmärkt': 1736,
'Ekologisk': 2167,
'Glutenfri': 2168,
'Laktosfri': 2169,
'Låglaktos': 2170,
'Premiumkvalité': 2171,
'Mjölkproteinfri': 2172,
# 'Nyhet': 2173,
'18Åldersgräns': 2174,
'Fairtrade': 2175,
'Svanenmärkt': 2176,
'Kravmärkt': 2177,
'Video': 2178,
'Äkta vara': 2181,
'Astma- och Allergiförbundet': 2184,
'test': 2187,
'Rosa bandet': 2190,
'Svenskt sigill': 2191,
'3+ dagar': 2194,
'5+ dagar': 2197,
'7+ dagar': 2200,
'10+ dagar': 2203,
'30+ dagar': 2206,
'Svenskt ursprung': 2209,
'Svensk fågel': 2212,
'4+ dagar': 2215,
'Vegansk': 2218,
'MSC': 2219,
'Strategisk produkt': 2222,
'Svenskt sigill klimatcertifierad': 2224,
'ASC': 2227,
'Från Sverige': 2230,
'Kött från Sverige': 2233,
'Mjölk från Sverige': 2236,
'Faroklass brandfarligt': 2239,
'Faroklass miljöfarligt': 2242,
'Faroklass skadligt': 2245,
'Faroklass Warning': 2248,
'Energiklass A+': 2251,
'Energiklass C': 2254,
'Energiklass D': 2257,
'Energiklass E': 2260,
'Energiklass A++': 2263,
'Energiklass A': 2266,
'Energiklass B': 2269,
}
return table[key] if key in table else None
def get_dynamic_property_id(key):
table = {
'Volume': 1,
'Weight': 2,
'KfpDfp': 3,
'LastSalesDay': 4,
'LastReceiptDay': 5,
'OldPz1': 6,
'OldPz2': 7,
'OldPz3': 8,
'MaxStock': 9,
'Season': 10,
'OrderFactor': 11,
'MinStock': 12,
'DfpLengthMM': 13,
'DfpWidthMM': 14,
'DfpHeightMM': 15,
'DfpWeightG': 16,
'DfpType': 17,
'SupplierArticleNumber': 18,
'AxfoodArticleId': 19,
'TruckrouteOptimizationProd3': 20,
'KfpHeightMM': 21,
'KfpLengthtMM': 22,
'KfpWidthMM': 23,
'IsFakeStockBalance': 24,
'ExternalImageUrl': 25,
'ProductSupplier': 26,
'ValdioDFPWidthMM': 27,
'ValdioDFPHeightMM': 28,
'ValidoDFPLengthtMM': 29,
'ValdioDFPWeightG': 30,
'DFPEANCode': 31,
'SafetyStock': 33,
'KfpDfpPurchaseOrder': 36,
'NoNutritionsNeeded': 38,
'NoIngredientsNeeded': 41,
'NoAllergensNeeded': 44,
'DeliveredUnitConversionFactor': 45,
'HandlingUnitQuantity': 46,
'BDMaterialNumber': 49,
'ProductSegment': 55,
'StandardUnitKfp': 56,
'StandardUnitGtin': 59,
'LimitedOfferProduct': 61,
'QLPricing': 64,
'QLMatching': 67,
'FirstSalesDate': 70,
'CategoryManager': 73,
}
return table[key] if key in table else None
def get_origin_id(key):
table = {
752: 1, # Svensk
249: 2, # Fransk
# TODO: MAP THIS ?: 3, # Afrika
# TODO: MAP THIS ?: 4, # Grekiskt
# TODO: MAP THIS ?: 5, # Indien
# TODO: MAP THIS ?: 6, # Nordamerika
# TODO: MAP THIS ?: 7, # Latinamerika
# TODO: MAP THIS ?: 8, # Orienten
# TODO: MAP THIS ?: 9, # Japan
# TODO: MAP THIS ?: 10, # Italienskt
# TODO: MAP THIS ?: 11, # Sydostasien
# TODO: MAP THIS ?: 12, # Spansk
# TODO: MAP THIS ?: 13, # Tyskland
# TODO: MAP THIS ?: 14, # "Ryssland och Östeuropa"
# TODO: MAP THIS ?: 15, # Internationellt
# TODO: MAP THIS ?: 16, # Övriga
# TODO: MAP THIS ?: 73, # Sverige
# TODO: MAP THIS ?: 74, # Norge
# TODO: MAP THIS ?: 75, # Kanada
# TODO: MAP THIS ?: 76, # Frankrike
# TODO: MAP THIS ?: 77, # Grekland
# TODO: MAP THIS ?: 78, # Portugal
# TODO: MAP THIS ?: 79, # Danmark
# TODO: MAP THIS ?: 80, # Italien
# TODO: MAP THIS ?: 81, # Finland
# TODO: MAP THIS ?: 82, # Kalifornien
# TODO: MAP THIS ?: 83, # Thailand
# TODO: MAP THIS ?: 84, # Kina
# TODO: MAP THIS ?: 85, # Belgien
# TODO: MAP THIS ?: 86, # Europa
# TODO: MAP THIS ?: 87, # Turkiet
# TODO: MAP THIS ?: 88, # Holland
# TODO: MAP THIS ?: 89, # England
# TODO: MAP THIS ?: 90, # Spanien
# TODO: MAP THIS ?: 91, # Nederländerna
# TODO: MAP THIS ?: 92, # Polen
# TODO: MAP THIS ?: 93, # "Blandat: EG och icke EG"
# TODO: MAP THIS ?: 94, # Ungern
# TODO: MAP THIS ?: 95, # Bulgarien
# TODO: MAP THIS ?: 96, # Kroatien
# TODO: MAP THIS ?: 98, # India
# TODO: MAP THIS ?: 99, # Uruguay
# TODO: MAP THIS ?: 100, # Irland
# TODO: MAP THIS ?: 101, # "Nya Zeeland"
# TODO: MAP THIS ?: 102, # Sverige/England
# TODO: MAP THIS ?: 103, # Sverige/Danmark
# TODO: MAP THIS ?: 104, # China
# TODO: MAP THIS ?: 105, # Holland/Frankrike
# TODO: MAP THIS ?: 106, # "Costa Rica"
# TODO: MAP THIS ?: 107, # Zaire
# TODO: MAP THIS ?: 108, # Israel/USA
# TODO: MAP | r_route_from_product_type(key):
t | identifier_name |
|
parser.go | /juniperUDP/port"
"github.com/golang/protobuf/proto"
_"strings"
)
// JuniperUDPParser is an object for Parsing incoming metrics.
type JuniperUDPParser struct {
// DefaultTags will be added to every parsed metric
DefaultTags map[string]string
}
/*
func (p *JuniperUDPParser) ParseWithDefaultTimePrecision(buf []byte, t time.Time, precision string) ([]telegraf.Metric, error) {
if !bytes.HasSuffix(buf, []byte("\n")) {
buf = append(buf, '\n')
}
// parse even if the buffer begins with a newline
buf = bytes.TrimPrefix(buf, []byte("\n"))
metrics, err := metric.ParseWithDefaultTimePrecision(buf, t, precision)
if len(p.DefaultTags) > 0 {
for _, m := range metrics {
for k, v := range p.DefaultTags {
// only set the default tag if it doesn't already exist:
if !m.HasTag(k) {
m.AddTag(k, v)
}
}
}
}
return metrics, err
}
*/
func parseArray(data []interface{}, masterKey string) []interface{} {
var arrData []interface{}
for _,val := range data{
valType := reflect.ValueOf(val).Kind()
if valType == reflect.Map{
mapData := parseMap(val.(map[string]interface{}), masterKey)
for _,tmpData := range(mapData){
arrData = append(arrData, tmpData)
}
} else {fmt.Println("Error!!!! Leaf elements in array are not coded. Please open a issue.")}
}
return arrData
}
func parseMap(data map[string]interface{}, masterKey string) []interface{} {
var leafData map[string]interface{}
var arrData []interface{}
var arrKey []string
var finalData []interface{}
var newMasterKey string
leafData = make(map[string]interface{})
for key,val := range data{
if masterKey == ""{
newMasterKey = key
} else {
newMasterKey = masterKey + "." + key
}
valType := reflect.ValueOf(val).Kind()
if valType == reflect.Map{
mapData := parseMap(val.(map[string]interface{}), newMasterKey)
if reflect.TypeOf(mapData).Kind() == reflect.Map{
var tmpArr []interface{}
tmpArr = append(tmpArr, mapData)
arrData = append(arrData, tmpArr)
} else if reflect.TypeOf(mapData).Kind() == reflect.Slice{
arrData = append(arrData, mapData)
}
arrKey = append(arrKey, newMasterKey)
} else if valType == reflect.Slice{
arrData = append(arrData, parseArray(val.([]interface{}), newMasterKey))
arrKey = append(arrKey, newMasterKey)
} else { leafData[newMasterKey] = val}
}
if len(leafData) != 0 {
for i,key := range arrKey{
_ = key
for _,data_aa := range arrData[i].([]interface{}){
leafTmp := leafData
if data_aa != nil {
if reflect.ValueOf(data_aa).Kind() == reflect.Map{
for key_aa, value_aa := range data_aa.(map[string]interface{}){
leafTmp[key_aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
} else {
for _,data_ha := range data_aa.([]interface{}){
leafTmp = leafData
for key_aa,value_aa := range data_ha.(map[string]interface{}){
leafTmp[key_aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
}
}
}
}
}
} else {finalData = arrData}
arrData = arrData[:0]
if (len(finalData) == 0) && (len(leafData)!= 0) {
finalData = append(finalData, leafData)
}
return finalData
}
// Parse returns a slice of Metrics from a text representation of a
// metric (in line-protocol format)
// with each metric separated by newlines. If any metrics fail to parse,
// a non-nil error will be returned in addition to the metrics that parsed
// successfully.
func (p *JuniperUDPParser) Parse(buf []byte) ([]telegraf.Metric, error) {
//out, _ := os.Create("telegraf_udp.log")
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
log.Fatal(err)
}
path := dir+"/logs"
if _, err := os.Stat(path); os.IsNotExist(err) {
os.Mkdir(path, 0777)
}
out, errFile := os.OpenFile("logs/telegraf_udp.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if errFile != nil {
log.Fatal(errFile)
}
prefix := ""
flag := log.LstdFlags | log.Lmicroseconds | log.Lshortfile
newLog := log.New(out, prefix, flag)
newLog.Printf("Data byte buffer received!!\n")
sensorMapping := map[string]string{"jnpr_interface_ext" : "/junos/system/linecard/interface/",
"cpu_memory_util_ext" : "/junos/system/linecard/cpu/memory/",
"fabricMessageExt" : "/junos/system/linecard/fabric",
"jnpr_firewall_ext" : "/junos/system/linecard/firewall/",
"jnprLogicalInterfaceExt" : "/junos/system/linecard/interface/logical/usage/",
"npu_memory_ext" : "/junos/system/linecard/npu/memory/",
"jnpr_npu_utilization_ext" : "/junos/system/linecard/npu/utilization/",
"jnpr_optics_ext" : "/junos/system/linecard/optics/",
"jnpr_packet_statistics_ext" : "/junos/system/linecard/packet/usage/",
"jnpr_qmon_ext" : "/junos/system/linecard/qmon/",
"inline_jflow_stats_ext" : "/junos/system/linecard/services/inline-jflow/",
"jnpr_cmerror_data_ext" : "NA",
"jnpr_cmerror_ext" : "NA",
"jnpr_lsp_statistics_ext" : "NA",
"jnpr_interface_exp_ext" : "NA",
"jnpr_sr_stats_per_if_egress_ext" : "NA",
"jnpr_sr_stats_per_if_ingress_ext" : "NA",
"jnpr_sr_stats_per_sid_ext" : "NA",
}
_ = sensorMapping
go func() {
for {
var m runtime.MemStats
runtime.ReadMemStats(&m)
//log.Printf("\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", m.Alloc / 1024, m.TotalAlloc / 1024, m.Sys / 1024, m.NumGC)
time.Sleep(5 * time.Second)
}
}()
//s := string(buf[:len(buf)])
//fmt.Println("#######################################################################")
//fmt.Printf("%v",s)
//fmt.Println("#######################################################################")
ts := &telemetry_top.TelemetryStream{}
if err := proto.Unmarshal(buf, ts); err != nil {
fmt.Println("Error!! Unable to parse data: ", err)
return nil,err
}
//fmt.Printf("%v",ts)
host,errHost := os.Hostname()
_ = host
if errHost != nil {
fmt.Println("Error!! Host name not found: ", errHost)
return nil, errHost
}
deviceName := ts.GetSystemId()
newLog.Printf("Device : %v", deviceName)
newLog.Printf("Host : %v", host)
gpbTime := ts.GetTimestamp()
measurementPrefix := "enterprise.juniperNetworks"
jnprSensorName := ts.GetSensorName()
sensorName := jnprSensorName
_ = gpbTime
_ = measurementPrefix
_ = jnprSensorName
m := &jsonpb.Marshaler{}
tsJSON,err := m.MarshalToString(ts)
if err!= nil{
fmt.Println("Error!! ", err)
}
var data map[string]interface{}
errU := json.Unmarshal([]byte(tsJSON), &data)
if errU != nil {
fmt.Println("Error!! Unable to unmarshal: ",errU)
return nil, nil
//panic(errU)
}
//newLog.Printf("Data received : %v", data)
enterpriseSensorData := data["enterprise"]
sensorData, ok := enterpriseSensorData.(map[string]interface{})
jnprSensorData := sensorData["[juniperNetworks]"]
if !ok {
return nil, nil
panic("inner map is not a map!")
}
metrics := make([]telegraf.Metric, 0)
sensorNum := 0 | random_line_split |
||
parser.go | uniperUDP/npu_utilization"
_"github.com/influxdata/telegraf/plugins/parsers/juniperUDP/optics"
_"github.com/influxdata/telegraf/plugins/parsers/juniperUDP/packet_stats"
_"github.com/influxdata/telegraf/plugins/parsers/juniperUDP/port_exp"
_"github.com/influxdata/telegraf/plugins/parsers/juniperUDP/port"
"github.com/golang/protobuf/proto"
_"strings"
)
// JuniperUDPParser is an object for Parsing incoming metrics.
type JuniperUDPParser struct {
// DefaultTags will be added to every parsed metric
DefaultTags map[string]string
}
/*
func (p *JuniperUDPParser) ParseWithDefaultTimePrecision(buf []byte, t time.Time, precision string) ([]telegraf.Metric, error) {
if !bytes.HasSuffix(buf, []byte("\n")) {
buf = append(buf, '\n')
}
// parse even if the buffer begins with a newline
buf = bytes.TrimPrefix(buf, []byte("\n"))
metrics, err := metric.ParseWithDefaultTimePrecision(buf, t, precision)
if len(p.DefaultTags) > 0 {
for _, m := range metrics {
for k, v := range p.DefaultTags {
// only set the default tag if it doesn't already exist:
if !m.HasTag(k) {
m.AddTag(k, v)
}
}
}
}
return metrics, err
}
*/
func parseArray(data []interface{}, masterKey string) []interface{} {
var arrData []interface{}
for _,val := range data{
valType := reflect.ValueOf(val).Kind()
if valType == reflect.Map{
mapData := parseMap(val.(map[string]interface{}), masterKey)
for _,tmpData := range(mapData){
arrData = append(arrData, tmpData)
}
} else {fmt.Println("Error!!!! Leaf elements in array are not coded. Please open a issue.")}
}
return arrData
}
func parseMap(data map[string]interface{}, masterKey string) []interface{} {
var leafData map[string]interface{}
var arrData []interface{}
var arrKey []string
var finalData []interface{}
var newMasterKey string
leafData = make(map[string]interface{})
for key,val := range data{
if masterKey == ""{
newMasterKey = key
} else {
newMasterKey = masterKey + "." + key
}
valType := reflect.ValueOf(val).Kind()
if valType == reflect.Map{
mapData := parseMap(val.(map[string]interface{}), newMasterKey)
if reflect.TypeOf(mapData).Kind() == reflect.Map{
var tmpArr []interface{}
tmpArr = append(tmpArr, mapData)
arrData = append(arrData, tmpArr)
} else if reflect.TypeOf(mapData).Kind() == reflect.Slice{
arrData = append(arrData, mapData)
}
arrKey = append(arrKey, newMasterKey)
} else if valType == reflect.Slice{
arrData = append(arrData, parseArray(val.([]interface{}), newMasterKey))
arrKey = append(arrKey, newMasterKey)
} else { leafData[newMasterKey] = val}
}
if len(leafData) != 0 {
for i,key := range arrKey{
_ = key
for _,data_aa := range arrData[i].([]interface{}){
leafTmp := leafData
if data_aa != nil {
if reflect.ValueOf(data_aa).Kind() == reflect.Map{
for key_aa, value_aa := range data_aa.(map[string]interface{}){
leafTmp[key_aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
} else {
for _,data_ha := range data_aa.([]interface{}){
leafTmp = leafData
for key_aa,value_aa := range data_ha.(map[string]interface{}){
leafTmp[key_aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
}
}
}
}
}
} else {finalData = arrData}
arrData = arrData[:0]
if (len(finalData) == 0) && (len(leafData)!= 0) {
finalData = append(finalData, leafData)
}
return finalData
}
// Parse returns a slice of Metrics from a text representation of a
// metric (in line-protocol format)
// with each metric separated by newlines. If any metrics fail to parse,
// a non-nil error will be returned in addition to the metrics that parsed
// successfully.
func (p *JuniperUDPParser) Parse(buf []byte) ([]telegraf.Metric, error) | "fabricMessageExt" : "/junos/system/linecard/fabric",
"jnpr_firewall_ext" : "/junos/system/linecard/firewall/",
"jnprLogicalInterfaceExt" : "/junos/system/linecard/interface/logical/usage/",
"npu_memory_ext" : "/junos/system/linecard/npu/memory/",
"jnpr_npu_utilization_ext" : "/junos/system/linecard/npu/utilization/",
"jnpr_optics_ext" : "/junos/system/linecard/optics/",
"jnpr_packet_statistics_ext" : "/junos/system/linecard/packet/usage/",
"jnpr_qmon_ext" : "/junos/system/linecard/qmon/",
"inline_jflow_stats_ext" : "/junos/system/linecard/services/inline-jflow/",
"jnpr_cmerror_data_ext" : "NA",
"jnpr_cmerror_ext" : "NA",
"jnpr_lsp_statistics_ext" : "NA",
"jnpr_interface_exp_ext" : "NA",
"jnpr_sr_stats_per_if_egress_ext" : "NA",
"jnpr_sr_stats_per_if_ingress_ext" : "NA",
"jnpr_sr_stats_per_sid_ext" : "NA",
}
_ = sensorMapping
go func() {
for {
var m runtime.MemStats
runtime.ReadMemStats(&m)
//log.Printf("\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", m.Alloc / 1024, m.TotalAlloc / 1024, m.Sys / 1024, m.NumGC)
time.Sleep(5 * time.Second)
}
}()
//s := string(buf[:len(buf)])
//fmt.Println("#######################################################################")
//fmt.Printf("%v",s)
//fmt.Println("#######################################################################")
ts := &telemetry_top.TelemetryStream{}
if err := proto.Unmarshal(buf, ts); err != nil {
fmt.Println("Error!! Unable to parse data: ", err)
return nil,err
}
//fmt.Printf("%v",ts)
host,errHost := os.Hostname()
_ = host
if errHost != nil {
fmt.Println("Error!! Host name not found: ", errHost)
return nil, errHost
}
deviceName := ts.GetSystemId()
newLog.Printf("Device : %v", deviceName)
newLog.Printf("Host : %v", host)
gpbTime := ts.GetTimestamp()
measurementPrefix := "enterprise.juniperNetworks"
jnprSensorName := ts.GetSensorName()
sensorName := jnprSensorName
_ = gpbTime
_ = measurementPrefix
_ = jnprSensorName
m := &jsonpb.Marshaler{}
tsJSON,err := m.MarshalToString(ts)
if err!= nil{
fmt.Println("Error!! ", err)
}
var data map[string]interface{}
errU := json.Unmarshal([]byte(tsJSON), &data)
if errU != nil {
fmt.Println("Error!! Unable to unmarshal: ",errU)
return nil, nil
//panic(errU)
}
//newLog.Printf("Data received : %v | {
//out, _ := os.Create("telegraf_udp.log")
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
log.Fatal(err)
}
path := dir+"/logs"
if _, err := os.Stat(path); os.IsNotExist(err) {
os.Mkdir(path, 0777)
}
out, errFile := os.OpenFile("logs/telegraf_udp.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if errFile != nil {
log.Fatal(errFile)
}
prefix := ""
flag := log.LstdFlags | log.Lmicroseconds | log.Lshortfile
newLog := log.New(out, prefix, flag)
newLog.Printf("Data byte buffer received!!\n")
sensorMapping := map[string]string{"jnpr_interface_ext" : "/junos/system/linecard/interface/",
"cpu_memory_util_ext" : "/junos/system/linecard/cpu/memory/", | identifier_body |
parser.go | .HasTag(k) {
m.AddTag(k, v)
}
}
}
}
return metrics, err
}
*/
func parseArray(data []interface{}, masterKey string) []interface{} {
var arrData []interface{}
for _,val := range data{
valType := reflect.ValueOf(val).Kind()
if valType == reflect.Map{
mapData := parseMap(val.(map[string]interface{}), masterKey)
for _,tmpData := range(mapData){
arrData = append(arrData, tmpData)
}
} else {fmt.Println("Error!!!! Leaf elements in array are not coded. Please open a issue.")}
}
return arrData
}
func parseMap(data map[string]interface{}, masterKey string) []interface{} {
var leafData map[string]interface{}
var arrData []interface{}
var arrKey []string
var finalData []interface{}
var newMasterKey string
leafData = make(map[string]interface{})
for key,val := range data{
if masterKey == ""{
newMasterKey = key
} else {
newMasterKey = masterKey + "." + key
}
valType := reflect.ValueOf(val).Kind()
if valType == reflect.Map{
mapData := parseMap(val.(map[string]interface{}), newMasterKey)
if reflect.TypeOf(mapData).Kind() == reflect.Map{
var tmpArr []interface{}
tmpArr = append(tmpArr, mapData)
arrData = append(arrData, tmpArr)
} else if reflect.TypeOf(mapData).Kind() == reflect.Slice{
arrData = append(arrData, mapData)
}
arrKey = append(arrKey, newMasterKey)
} else if valType == reflect.Slice{
arrData = append(arrData, parseArray(val.([]interface{}), newMasterKey))
arrKey = append(arrKey, newMasterKey)
} else { leafData[newMasterKey] = val}
}
if len(leafData) != 0 {
for i,key := range arrKey{
_ = key
for _,data_aa := range arrData[i].([]interface{}){
leafTmp := leafData
if data_aa != nil {
if reflect.ValueOf(data_aa).Kind() == reflect.Map{
for key_aa, value_aa := range data_aa.(map[string]interface{}){
leafTmp[key_aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
} else {
for _,data_ha := range data_aa.([]interface{}){
leafTmp = leafData
for key_aa,value_aa := range data_ha.(map[string]interface{}){
leafTmp[key_aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
}
}
}
}
}
} else {finalData = arrData}
arrData = arrData[:0]
if (len(finalData) == 0) && (len(leafData)!= 0) {
finalData = append(finalData, leafData)
}
return finalData
}
// Parse returns a slice of Metrics from a text representation of a
// metric (in line-protocol format)
// with each metric separated by newlines. If any metrics fail to parse,
// a non-nil error will be returned in addition to the metrics that parsed
// successfully.
func (p *JuniperUDPParser) Parse(buf []byte) ([]telegraf.Metric, error) {
//out, _ := os.Create("telegraf_udp.log")
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
log.Fatal(err)
}
path := dir+"/logs"
if _, err := os.Stat(path); os.IsNotExist(err) {
os.Mkdir(path, 0777)
}
out, errFile := os.OpenFile("logs/telegraf_udp.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if errFile != nil {
log.Fatal(errFile)
}
prefix := ""
flag := log.LstdFlags | log.Lmicroseconds | log.Lshortfile
newLog := log.New(out, prefix, flag)
newLog.Printf("Data byte buffer received!!\n")
sensorMapping := map[string]string{"jnpr_interface_ext" : "/junos/system/linecard/interface/",
"cpu_memory_util_ext" : "/junos/system/linecard/cpu/memory/",
"fabricMessageExt" : "/junos/system/linecard/fabric",
"jnpr_firewall_ext" : "/junos/system/linecard/firewall/",
"jnprLogicalInterfaceExt" : "/junos/system/linecard/interface/logical/usage/",
"npu_memory_ext" : "/junos/system/linecard/npu/memory/",
"jnpr_npu_utilization_ext" : "/junos/system/linecard/npu/utilization/",
"jnpr_optics_ext" : "/junos/system/linecard/optics/",
"jnpr_packet_statistics_ext" : "/junos/system/linecard/packet/usage/",
"jnpr_qmon_ext" : "/junos/system/linecard/qmon/",
"inline_jflow_stats_ext" : "/junos/system/linecard/services/inline-jflow/",
"jnpr_cmerror_data_ext" : "NA",
"jnpr_cmerror_ext" : "NA",
"jnpr_lsp_statistics_ext" : "NA",
"jnpr_interface_exp_ext" : "NA",
"jnpr_sr_stats_per_if_egress_ext" : "NA",
"jnpr_sr_stats_per_if_ingress_ext" : "NA",
"jnpr_sr_stats_per_sid_ext" : "NA",
}
_ = sensorMapping
go func() {
for {
var m runtime.MemStats
runtime.ReadMemStats(&m)
//log.Printf("\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", m.Alloc / 1024, m.TotalAlloc / 1024, m.Sys / 1024, m.NumGC)
time.Sleep(5 * time.Second)
}
}()
//s := string(buf[:len(buf)])
//fmt.Println("#######################################################################")
//fmt.Printf("%v",s)
//fmt.Println("#######################################################################")
ts := &telemetry_top.TelemetryStream{}
if err := proto.Unmarshal(buf, ts); err != nil {
fmt.Println("Error!! Unable to parse data: ", err)
return nil,err
}
//fmt.Printf("%v",ts)
host,errHost := os.Hostname()
_ = host
if errHost != nil {
fmt.Println("Error!! Host name not found: ", errHost)
return nil, errHost
}
deviceName := ts.GetSystemId()
newLog.Printf("Device : %v", deviceName)
newLog.Printf("Host : %v", host)
gpbTime := ts.GetTimestamp()
measurementPrefix := "enterprise.juniperNetworks"
jnprSensorName := ts.GetSensorName()
sensorName := jnprSensorName
_ = gpbTime
_ = measurementPrefix
_ = jnprSensorName
m := &jsonpb.Marshaler{}
tsJSON,err := m.MarshalToString(ts)
if err!= nil{
fmt.Println("Error!! ", err)
}
var data map[string]interface{}
errU := json.Unmarshal([]byte(tsJSON), &data)
if errU != nil {
fmt.Println("Error!! Unable to unmarshal: ",errU)
return nil, nil
//panic(errU)
}
//newLog.Printf("Data received : %v", data)
enterpriseSensorData := data["enterprise"]
sensorData, ok := enterpriseSensorData.(map[string]interface{})
jnprSensorData := sensorData["[juniperNetworks]"]
if !ok {
return nil, nil
panic("inner map is not a map!")
}
metrics := make([]telegraf.Metric, 0)
sensorNum := 0
sequenceNum := 0
for key, sensorData := range jnprSensorData.(map[string]interface{}) | {
var fields map[string]interface{}
if reflect.ValueOf(sensorData).Kind() == reflect.Map {
_ = sensorName
sensorName = key[1:len(key)-1]
var measurementName string
measurementName = sensorName
/*
if val, ok := sensorMapping[sensorName]; ok {
measurementName = val
} else {
measurementName = sensorName
}
*/
newLog.Printf("Sensor : %v", measurementName)
measurementName = "juniperNetworks." + measurementName
newLog.Printf("Measurement : %v", measurementName)
//newLog.Printf("Data received : %v", data)
parsedData := parseMap(sensorData.(map[string]interface{}), "")
for _,finalData := range(parsedData){ | conditional_block |
|
parser.go | _aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
} else {
for _,data_ha := range data_aa.([]interface{}){
leafTmp = leafData
for key_aa,value_aa := range data_ha.(map[string]interface{}){
leafTmp[key_aa] = value_aa
}
finalData = append(finalData, make(map[string]interface{}))
for k,v := range leafTmp{
finalData[len(finalData)-1].(map[string]interface{})[k] = v
}
}
}
}
}
}
} else {finalData = arrData}
arrData = arrData[:0]
if (len(finalData) == 0) && (len(leafData)!= 0) {
finalData = append(finalData, leafData)
}
return finalData
}
// Parse returns a slice of Metrics from a text representation of a
// metric (in line-protocol format)
// with each metric separated by newlines. If any metrics fail to parse,
// a non-nil error will be returned in addition to the metrics that parsed
// successfully.
func (p *JuniperUDPParser) Parse(buf []byte) ([]telegraf.Metric, error) {
//out, _ := os.Create("telegraf_udp.log")
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
log.Fatal(err)
}
path := dir+"/logs"
if _, err := os.Stat(path); os.IsNotExist(err) {
os.Mkdir(path, 0777)
}
out, errFile := os.OpenFile("logs/telegraf_udp.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if errFile != nil {
log.Fatal(errFile)
}
prefix := ""
flag := log.LstdFlags | log.Lmicroseconds | log.Lshortfile
newLog := log.New(out, prefix, flag)
newLog.Printf("Data byte buffer received!!\n")
sensorMapping := map[string]string{"jnpr_interface_ext" : "/junos/system/linecard/interface/",
"cpu_memory_util_ext" : "/junos/system/linecard/cpu/memory/",
"fabricMessageExt" : "/junos/system/linecard/fabric",
"jnpr_firewall_ext" : "/junos/system/linecard/firewall/",
"jnprLogicalInterfaceExt" : "/junos/system/linecard/interface/logical/usage/",
"npu_memory_ext" : "/junos/system/linecard/npu/memory/",
"jnpr_npu_utilization_ext" : "/junos/system/linecard/npu/utilization/",
"jnpr_optics_ext" : "/junos/system/linecard/optics/",
"jnpr_packet_statistics_ext" : "/junos/system/linecard/packet/usage/",
"jnpr_qmon_ext" : "/junos/system/linecard/qmon/",
"inline_jflow_stats_ext" : "/junos/system/linecard/services/inline-jflow/",
"jnpr_cmerror_data_ext" : "NA",
"jnpr_cmerror_ext" : "NA",
"jnpr_lsp_statistics_ext" : "NA",
"jnpr_interface_exp_ext" : "NA",
"jnpr_sr_stats_per_if_egress_ext" : "NA",
"jnpr_sr_stats_per_if_ingress_ext" : "NA",
"jnpr_sr_stats_per_sid_ext" : "NA",
}
_ = sensorMapping
go func() {
for {
var m runtime.MemStats
runtime.ReadMemStats(&m)
//log.Printf("\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", m.Alloc / 1024, m.TotalAlloc / 1024, m.Sys / 1024, m.NumGC)
time.Sleep(5 * time.Second)
}
}()
//s := string(buf[:len(buf)])
//fmt.Println("#######################################################################")
//fmt.Printf("%v",s)
//fmt.Println("#######################################################################")
ts := &telemetry_top.TelemetryStream{}
if err := proto.Unmarshal(buf, ts); err != nil {
fmt.Println("Error!! Unable to parse data: ", err)
return nil,err
}
//fmt.Printf("%v",ts)
host,errHost := os.Hostname()
_ = host
if errHost != nil {
fmt.Println("Error!! Host name not found: ", errHost)
return nil, errHost
}
deviceName := ts.GetSystemId()
newLog.Printf("Device : %v", deviceName)
newLog.Printf("Host : %v", host)
gpbTime := ts.GetTimestamp()
measurementPrefix := "enterprise.juniperNetworks"
jnprSensorName := ts.GetSensorName()
sensorName := jnprSensorName
_ = gpbTime
_ = measurementPrefix
_ = jnprSensorName
m := &jsonpb.Marshaler{}
tsJSON,err := m.MarshalToString(ts)
if err!= nil{
fmt.Println("Error!! ", err)
}
var data map[string]interface{}
errU := json.Unmarshal([]byte(tsJSON), &data)
if errU != nil {
fmt.Println("Error!! Unable to unmarshal: ",errU)
return nil, nil
//panic(errU)
}
//newLog.Printf("Data received : %v", data)
enterpriseSensorData := data["enterprise"]
sensorData, ok := enterpriseSensorData.(map[string]interface{})
jnprSensorData := sensorData["[juniperNetworks]"]
if !ok {
return nil, nil
panic("inner map is not a map!")
}
metrics := make([]telegraf.Metric, 0)
sensorNum := 0
sequenceNum := 0
for key, sensorData := range jnprSensorData.(map[string]interface{}){
var fields map[string]interface{}
if reflect.ValueOf(sensorData).Kind() == reflect.Map {
_ = sensorName
sensorName = key[1:len(key)-1]
var measurementName string
measurementName = sensorName
/*
if val, ok := sensorMapping[sensorName]; ok {
measurementName = val
} else {
measurementName = sensorName
}
*/
newLog.Printf("Sensor : %v", measurementName)
measurementName = "juniperNetworks." + measurementName
newLog.Printf("Measurement : %v", measurementName)
//newLog.Printf("Data received : %v", data)
parsedData := parseMap(sensorData.(map[string]interface{}), "")
for _,finalData := range(parsedData){
//sequenceNum := 0
for _,fin := range(finalData.([]interface{})){
//fin = fin.(map[string] interface{})
fin.(map[string]interface{})["device"] = deviceName
//fin.(map[string]interface{})["host"] = host
fin.(map[string]interface{})["sensor_name"] = sensorName
//fin.(map[string]interface{})["_seq"] = sequenceNum
fields = fin.(map[string]interface{})
tags := make(map[string]string)
for k, v := range p.DefaultTags {
tags[k] = v
}
tags["_seq"] = strconv.Itoa(sequenceNum)
timestamp := time.Unix(int64(gpbTime)/1000, int64(gpbTime)%1000*1000000)
mtrc,err := metric.New(measurementName, tags, fields,timestamp)
metrics = append(metrics, mtrc)
if err!=nil {
fmt.Println("Error!! Unable to create telegraf metrics: ", err)
}
sensorNum++
sequenceNum++
}
}
}
}
// fmt.Printf("\nData (JSON) = \n%s\n", data)
// fmt.Println("\nJuniper Sensor Name: \n%s\n", jnprSensorName)
// fmt.Println("\nDevice name: \n%s\n", deviceName)
// fmt.Println("\nGPB time: \n%s\n", gpbTime)
// fmt.Println(measurementPrefix)
// fmt.Println("\nMetrics: \n")
// fmt.Println(metrics)
newLog.Printf("Parsed Data : %v\n", metrics)
if errFileClose := out.Close(); err != nil {
log.Fatal(errFileClose)
}
return metrics, err
// return p.ParseWithDefaultTimePrecision(buf, time.Now(), "")
}
func (p *JuniperUDPParser) ParseLine(line string) (telegraf.Metric, error) {
metrics, err := p.Parse([]byte(line + "\n"))
if err != nil {
return nil, err
}
if len(metrics) < 1 {
return nil, fmt.Errorf(
"Can not parse the line: %s, for data format: influx ", line)
}
return metrics[0], nil
}
func (p *JuniperUDPParser) | SetDefaultTags | identifier_name |
|
alain.js | resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildAlain = exports.addValueToVariable = exports.addProviderToModule = exports.addImportToModule = exports.refreshPathRoot = void 0;
const core_1 = require("@angular-devkit/core");
const schematics_1 = require("@angular-devkit/schematics");
const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
const change_1 = require("@schematics/angular/utility/change");
const find_module_1 = require("@schematics/angular/utility/find-module");
const parse_name_1 = require("@schematics/angular/utility/parse-name");
const validation_1 = require("@schematics/angular/utility/validation");
const fs = require("fs");
const path = require("path");
const ts = require("typescript");
const ast_1 = require("./ast");
const workspace_1 = require("./workspace");
const TEMPLATE_FILENAME_RE = /\.template$/;
function buildSelector(schema, projectPrefix) {
const ret = [];
if (!schema.withoutPrefix) {
if (schema.prefix) {
ret.push(schema.prefix);
}
else if (schema.prefix === undefined && projectPrefix) {
ret.push(projectPrefix);
}
}
// module name
if (schema.module) {
ret.push(schema.module);
}
// target name
if (schema.target) {
ret.push(...schema.target.split('/'));
}
// name
ret.push(core_1.strings.dasherize(schema.name));
return ret.join('-');
}
function buildName(schema, prefix) {
const ret = schema.withoutModulePrefixInComponentName === true ? [] : [schema.module];
if (schema.target && schema.target.length > 0) {
ret.push(...schema.target.split('/'));
}
ret.push(schema.name);
// 服务类自动过滤 list, empty 两个页面的后缀
if (prefix === 'Service' && ['list', 'empty'].includes(schema.name)) {
ret.pop();
}
ret.push(prefix);
return core_1.strings.classify(ret.join('-'));
}
function refreshPathRoot(project, sch | ct) {
var _a;
if (schema.path === undefined) {
schema.path = `/${path.join(project.sourceRoot, (_a = alainProject === null || alainProject === void 0 ? void 0 : alainProject.routesRoot) !== null && _a !== void 0 ? _a : 'app/routes')}`;
}
}
exports.refreshPathRoot = refreshPathRoot;
function resolveSchema(tree, project, schema, alainProject) {
// module name
if (!schema.module) {
throw new schematics_1.SchematicsException(`Must specify module name. (e.g: ng g ng-alain:list <list name> -m=<module name>)`);
}
// path
refreshPathRoot(project, schema, alainProject);
schema.path += `/${schema.module}`;
const parsedPath = (0, parse_name_1.parseName)(schema.path, schema.name);
schema.name = parsedPath.name;
schema.path = parsedPath.path;
const rootPath = path.resolve(__dirname, '../../..');
const fullPath = path.join(rootPath, schema.path, schema.name);
if (fs.existsSync(fullPath) && fs.readdirSync(fullPath).length > 0) {
throw new schematics_1.SchematicsException(`The directory (${fullPath}) already exists`);
}
schema.importModulePath = (0, find_module_1.findModuleFromOptions)(tree, schema);
if (!schema._filesPath) {
// 若基础页尝试从 `_cli-tpl/_${schema.schematicName!}` 下查找该目录，若存在则优先使用
if (['list', 'edit', 'view', 'empty'].includes(schema.schematicName)) {
const overrideDir = `/${[project.root, `_cli-tpl/_${schema.schematicName}`].filter(i => !!i).join('/')}`;
const overridePath = `${overrideDir}/__path__/__name@dasherize@if-flat__/__name@dasherize__.component.ts`;
if (tree.exists(overridePath) || tree.exists(`${overridePath}.template`)) {
// 所在目录与命令目录同属一个目录结构，因此无须特殊处理
schema._filesPath = path.relative(__dirname, rootPath) + overrideDir;
}
}
schema._filesPath = schema._filesPath || './files';
}
// fill target
if (schema.target) {
schema.path += core_1.strings.dasherize(`/${schema.target}`);
}
schema.routerModulePath = schema.importModulePath.replace('.module.ts', '-routing.module.ts');
// html selector
schema.selector = schema.selector || buildSelector(schema, project.prefix);
(0, validation_1.validateHtmlSelector)(schema.selector);
}
function addImportToModule(tree, filePath, symbolName, fileName) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const change = (0, ast_utils_1.insertImport)(source, filePath, symbolName, fileName);
if (change.path == null)
return;
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addImportToModule = addImportToModule;
function addProviderToModule(tree, filePath, serviceName, importPath) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const changes = (0, ast_utils_1.addProviderToModule)(source, filePath, serviceName, importPath);
const declarationRecorder = tree.beginUpdate(filePath);
changes.forEach(change => {
if (change.path == null)
return;
if (change instanceof change_1.InsertChange) {
declarationRecorder.insertLeft(change.pos, change.toAdd);
}
});
tree.commitUpdate(declarationRecorder);
}
exports.addProviderToModule = addProviderToModule;
function addValueToVariable(tree, filePath, variableName, text, needWrap = true) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const node = (0, ast_utils_1.findNode)(source, ts.SyntaxKind.Identifier, variableName);
if (!node) {
throw new schematics_1.SchematicsException(`Could not find any [${variableName}] variable in path '${filePath}'.`);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const arr = node.parent.initializer;
const change = new change_1.InsertChange(filePath, arr.end - 1, `${arr.elements && arr.elements.length > 0 ? ',' : ''}${needWrap ? '\n ' : ''}${text}`);
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addValueToVariable = addValueToVariable;
function getRelativePath(filePath, schema, prefix) {
const importPath = `/${schema.path}/${schema.flat ? '' : `${core_1.strings.dasherize(schema.name)}/`}${core_1.strings.dasherize(schema.name)}.${prefix}`;
return (0, find_module_1.buildRelativePath)(filePath, importPath);
}
function addDeclaration(schema) {
return (tree) => {
if (schema.skipImport || !schema.module) {
return tree;
}
// imports
addImportToModule(tree, schema.importModulePath, schema.componentName, getRelativePath(schema.importModulePath, schema, 'component'));
addValueToVariable(tree, schema.importModulePath, 'COMPONENTS', schema.componentName);
// component
if (schema.modal !== true) {
// routing
addImportToModule(tree, schema.routerModulePath, schema.componentName, getRelativePath(schema.routerModulePath, schema, 'component'));
addValueToVariable(tree, schema.routerModulePath, 'routes', `{ path: '${schema.name}', component: ${schema.componentName} }`);
}
// service
if (schema.service === 'none') {
addProviderToModule(tree, schema.importModulePath, schema.serviceName, getRelativePath(schema.importModulePath, schema, 'service'));
}
return tree;
};
}
function buildAlain(schema) {
return (tree) => __awaiter(this, void 0, void 0, function* () {
const res = yield (0, workspace_1.getProject)(tree, schema.project);
if (schema.project && res.name !== schema.project) {
throw new schematics_1.SchematicsException(`The specified project does not match '${schema.project}', current: ${res.name}`);
}
const project = res.project;
resolveSchema(tree, project, schema, res.alainProject);
schema.componentName = buildName(schema, 'Component');
schema.serviceName = buildName(schema, 'Service');
// Don't support inline
schema.inlineTemplate = false;
const templateSource = (0, schematics_1.apply)((0, schematics_1.url)(schema._filesPath), [
(0, schematics_1.filter)(filePath => !filePath.endsWith('.DS_Store')),
schema.service === 'ignore' ? (0, schematics_1.filter)(filePath => !filePath.endsWith('.service.ts.template')) : (0, | ema, alainProje | identifier_name |
alain.js | ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildAlain = exports.addValueToVariable = exports.addProviderToModule = exports.addImportToModule = exports.refreshPathRoot = void 0;
const core_1 = require("@angular-devkit/core");
const schematics_1 = require("@angular-devkit/schematics");
const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
const change_1 = require("@schematics/angular/utility/change");
const find_module_1 = require("@schematics/angular/utility/find-module");
const parse_name_1 = require("@schematics/angular/utility/parse-name");
const validation_1 = require("@schematics/angular/utility/validation");
const fs = require("fs");
const path = require("path");
const ts = require("typescript");
const ast_1 = require("./ast");
const workspace_1 = require("./workspace");
const TEMPLATE_FILENAME_RE = /\.template$/;
function buildSelector(schema, projectPrefix) {
const ret = [];
if (!schema.withoutPrefix) {
if (schema.prefix) {
ret.push(schema.prefix);
}
else if (schema.prefix === undefined && projectPrefix) {
ret.push(projectPrefix);
}
}
// module name
if (schema.module) {
ret.push(schema.module);
}
// target name
if (schema.target) {
ret.push(...schema.target.split('/'));
}
// name
ret.push(core_1.strings.dasherize(schema.name));
return ret.join('-');
}
function buildName(schema, prefix) {
const ret = schema.withoutModulePrefixInComponentName === true ? [] : [schema.module];
if (schema.target && schema.target.length > 0) {
ret.push(...schema.target.split('/'));
}
ret.push(schema.name);
// 服务类自动过滤 list, empty 两个页面的后缀
if (prefix === 'Service' && ['list', 'empty'].includes(schema.name)) {
ret.pop();
}
ret.push(prefix);
return core_1.strings.classify(ret.join('-'));
}
function refreshPathRoot(project, schema, alainProject) {
var _a;
if (schema.path === undefined) {
schema.path = `/${path.join(project.sourceRoot, (_a = alainProject === null || alainProject === void 0 ? void 0 : alainProject.routesRoot) !== null && _a !== void 0 ? _a : 'app/routes')}`;
}
}
exports.refreshPathRoot = refreshPathRoot;
function resolveSchema(tree, project, schema, alainProject) {
// module name
if (!schema.module) {
throw new schematics_1.SchematicsException(`Must specify module name. (e.g: ng g ng-alain:list <list name> -m=<module name>)`);
}
// path
refreshPathRoot(project, schema, alainProject);
schema.path += `/${schema.module}`;
const parsedPath = (0, parse_name_1.parseName)(schema.path, schema.name);
schema.name = parsedPath.name;
schema.path = parsedPath.path;
const rootPath = path.resolve(__dirname, '../../..');
const fullPath = path.join(rootPath, schema.path, schema.name);
if (fs.existsSync(fullPath) && fs.readdirSync(fullPath).length > 0) {
throw new schematics_1.SchematicsException(`The directory (${fullPath}) already exists`);
}
schema.importModulePath = (0, find_module_1.findModuleFromOptions)(tree, schema);
if (!schema._filesPath) {
// 若基础页尝试从 `_cli-tpl/_${schema.schematicName!}` 下查找该目录，若存在则优先使用
if (['list', 'edit', 'view', 'empty'].includes(schema.schematicName)) {
const overrideDir = `/${[project.root, `_cli-tpl/_${schema.schematicName}`].filter(i => !!i).join('/')}`;
const overridePath = `${overrideDir}/__path__/__name@dasherize@if-flat__/__name@dasherize__.component.ts`;
if (tree.exists(overridePath) || tree.exists(`${overridePath}.template`)) {
// 所在目录与命令目录同属一个目录结构，因此无须特殊处理
schema._filesPath = path.relative(__dirname, rootPath) + overrideDir;
}
}
schema._filesPath = schema._filesPath || './files';
}
// fill target
if (schema.target) {
schema.path += core_1.strings.dasherize(`/${schema.target}`);
}
schema.routerModulePath = schema.importModulePath.replace('.module.ts', '-routing.module.ts');
// html selector
schema.selector = schema.selector || buildSelector(schema, project.prefix);
(0, validation_1.validateHtmlSelector)(schema.selector);
}
function addImportToModule(tree, filePath, symbolName, fileName) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const change = (0, ast_utils_1.insertImport)(source, filePath, symbolName, fileName);
if (change.path == null)
return;
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addImportToModule = addImportToModule;
function addProviderToModule(tree, filePath, serviceName, importPath) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const changes = (0, ast_utils_1.addProviderToModule)(sour | = true) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const node = (0, ast_utils_1.findNode)(source, ts.SyntaxKind.Identifier, variableName);
if (!node) {
throw new schematics_1.SchematicsException(`Could not find any [${variableName}] variable in path '${filePath}'.`);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const arr = node.parent.initializer;
const change = new change_1.InsertChange(filePath, arr.end - 1, `${arr.elements && arr.elements.length > 0 ? ',' : ''}${needWrap ? '\n ' : ''}${text}`);
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addValueToVariable = addValueToVariable;
function getRelativePath(filePath, schema, prefix) {
const importPath = `/${schema.path}/${schema.flat ? '' : `${core_1.strings.dasherize(schema.name)}/`}${core_1.strings.dasherize(schema.name)}.${prefix}`;
return (0, find_module_1.buildRelativePath)(filePath, importPath);
}
function addDeclaration(schema) {
return (tree) => {
if (schema.skipImport || !schema.module) {
return tree;
}
// imports
addImportToModule(tree, schema.importModulePath, schema.componentName, getRelativePath(schema.importModulePath, schema, 'component'));
addValueToVariable(tree, schema.importModulePath, 'COMPONENTS', schema.componentName);
// component
if (schema.modal !== true) {
// routing
addImportToModule(tree, schema.routerModulePath, schema.componentName, getRelativePath(schema.routerModulePath, schema, 'component'));
addValueToVariable(tree, schema.routerModulePath, 'routes', `{ path: '${schema.name}', component: ${schema.componentName} }`);
}
// service
if (schema.service === 'none') {
addProviderToModule(tree, schema.importModulePath, schema.serviceName, getRelativePath(schema.importModulePath, schema, 'service'));
}
return tree;
};
}
function buildAlain(schema) {
return (tree) => __awaiter(this, void 0, void 0, function* () {
const res = yield (0, workspace_1.getProject)(tree, schema.project);
if (schema.project && res.name !== schema.project) {
throw new schematics_1.SchematicsException(`The specified project does not match '${schema.project}', current: ${res.name}`);
}
const project = res.project;
resolveSchema(tree, project, schema, res.alainProject);
schema.componentName = buildName(schema, 'Component');
schema.serviceName = buildName(schema, 'Service');
// Don't support inline
schema.inlineTemplate = false;
const templateSource = (0, schematics_1.apply)((0, schematics_1.url)(schema._filesPath), [
(0, schematics_1.filter)(filePath => !filePath.endsWith('.DS_Store')),
schema.service === 'ignore' ? (0, schematics_1.filter)(filePath => !filePath.endsWith('.service.ts.template')) : (0, | ce, filePath, serviceName, importPath);
const declarationRecorder = tree.beginUpdate(filePath);
changes.forEach(change => {
if (change.path == null)
return;
if (change instanceof change_1.InsertChange) {
declarationRecorder.insertLeft(change.pos, change.toAdd);
}
});
tree.commitUpdate(declarationRecorder);
}
exports.addProviderToModule = addProviderToModule;
function addValueToVariable(tree, filePath, variableName, text, needWrap | identifier_body |
alain.js | ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildAlain = exports.addValueToVariable = exports.addProviderToModule = exports.addImportToModule = exports.refreshPathRoot = void 0;
const core_1 = require("@angular-devkit/core");
const schematics_1 = require("@angular-devkit/schematics");
const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
const change_1 = require("@schematics/angular/utility/change");
const find_module_1 = require("@schematics/angular/utility/find-module");
const parse_name_1 = require("@schematics/angular/utility/parse-name");
const validation_1 = require("@schematics/angular/utility/validation");
const fs = require("fs");
const path = require("path");
const ts = require("typescript");
const ast_1 = require("./ast");
const workspace_1 = require("./workspace");
const TEMPLATE_FILENAME_RE = /\.template$/;
function buildSelector(schema, projectPrefix) {
const ret = [];
if (!schema.withoutPrefix) {
if (schema.prefix) {
ret.push(schema.prefix);
}
else if (schema.prefix === undefined && projectPrefix) |
}
// module name
if (schema.module) {
ret.push(schema.module);
}
// target name
if (schema.target) {
ret.push(...schema.target.split('/'));
}
// name
ret.push(core_1.strings.dasherize(schema.name));
return ret.join('-');
}
function buildName(schema, prefix) {
const ret = schema.withoutModulePrefixInComponentName === true ? [] : [schema.module];
if (schema.target && schema.target.length > 0) {
ret.push(...schema.target.split('/'));
}
ret.push(schema.name);
// 服务类自动过滤 list, empty 两个页面的后缀
if (prefix === 'Service' && ['list', 'empty'].includes(schema.name)) {
ret.pop();
}
ret.push(prefix);
return core_1.strings.classify(ret.join('-'));
}
function refreshPathRoot(project, schema, alainProject) {
var _a;
if (schema.path === undefined) {
schema.path = `/${path.join(project.sourceRoot, (_a = alainProject === null || alainProject === void 0 ? void 0 : alainProject.routesRoot) !== null && _a !== void 0 ? _a : 'app/routes')}`;
}
}
exports.refreshPathRoot = refreshPathRoot;
function resolveSchema(tree, project, schema, alainProject) {
// module name
if (!schema.module) {
throw new schematics_1.SchematicsException(`Must specify module name. (e.g: ng g ng-alain:list <list name> -m=<module name>)`);
}
// path
refreshPathRoot(project, schema, alainProject);
schema.path += `/${schema.module}`;
const parsedPath = (0, parse_name_1.parseName)(schema.path, schema.name);
schema.name = parsedPath.name;
schema.path = parsedPath.path;
const rootPath = path.resolve(__dirname, '../../..');
const fullPath = path.join(rootPath, schema.path, schema.name);
if (fs.existsSync(fullPath) && fs.readdirSync(fullPath).length > 0) {
throw new schematics_1.SchematicsException(`The directory (${fullPath}) already exists`);
}
schema.importModulePath = (0, find_module_1.findModuleFromOptions)(tree, schema);
if (!schema._filesPath) {
// 若基础页尝试从 `_cli-tpl/_${schema.schematicName!}` 下查找该目录，若存在则优先使用
if (['list', 'edit', 'view', 'empty'].includes(schema.schematicName)) {
const overrideDir = `/${[project.root, `_cli-tpl/_${schema.schematicName}`].filter(i => !!i).join('/')}`;
const overridePath = `${overrideDir}/__path__/__name@dasherize@if-flat__/__name@dasherize__.component.ts`;
if (tree.exists(overridePath) || tree.exists(`${overridePath}.template`)) {
// 所在目录与命令目录同属一个目录结构，因此无须特殊处理
schema._filesPath = path.relative(__dirname, rootPath) + overrideDir;
}
}
schema._filesPath = schema._filesPath || './files';
}
// fill target
if (schema.target) {
schema.path += core_1.strings.dasherize(`/${schema.target}`);
}
schema.routerModulePath = schema.importModulePath.replace('.module.ts', '-routing.module.ts');
// html selector
schema.selector = schema.selector || buildSelector(schema, project.prefix);
(0, validation_1.validateHtmlSelector)(schema.selector);
}
function addImportToModule(tree, filePath, symbolName, fileName) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const change = (0, ast_utils_1.insertImport)(source, filePath, symbolName, fileName);
if (change.path == null)
return;
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addImportToModule = addImportToModule;
function addProviderToModule(tree, filePath, serviceName, importPath) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const changes = (0, ast_utils_1.addProviderToModule)(source, filePath, serviceName, importPath);
const declarationRecorder = tree.beginUpdate(filePath);
changes.forEach(change => {
if (change.path == null)
return;
if (change instanceof change_1.InsertChange) {
declarationRecorder.insertLeft(change.pos, change.toAdd);
}
});
tree.commitUpdate(declarationRecorder);
}
exports.addProviderToModule = addProviderToModule;
function addValueToVariable(tree, filePath, variableName, text, needWrap = true) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const node = (0, ast_utils_1.findNode)(source, ts.SyntaxKind.Identifier, variableName);
if (!node) {
throw new schematics_1.SchematicsException(`Could not find any [${variableName}] variable in path '${filePath}'.`);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const arr = node.parent.initializer;
const change = new change_1.InsertChange(filePath, arr.end - 1, `${arr.elements && arr.elements.length > 0 ? ',' : ''}${needWrap ? '\n ' : ''}${text}`);
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addValueToVariable = addValueToVariable;
function getRelativePath(filePath, schema, prefix) {
const importPath = `/${schema.path}/${schema.flat ? '' : `${core_1.strings.dasherize(schema.name)}/`}${core_1.strings.dasherize(schema.name)}.${prefix}`;
return (0, find_module_1.buildRelativePath)(filePath, importPath);
}
function addDeclaration(schema) {
return (tree) => {
if (schema.skipImport || !schema.module) {
return tree;
}
// imports
addImportToModule(tree, schema.importModulePath, schema.componentName, getRelativePath(schema.importModulePath, schema, 'component'));
addValueToVariable(tree, schema.importModulePath, 'COMPONENTS', schema.componentName);
// component
if (schema.modal !== true) {
// routing
addImportToModule(tree, schema.routerModulePath, schema.componentName, getRelativePath(schema.routerModulePath, schema, 'component'));
addValueToVariable(tree, schema.routerModulePath, 'routes', `{ path: '${schema.name}', component: ${schema.componentName} }`);
}
// service
if (schema.service === 'none') {
addProviderToModule(tree, schema.importModulePath, schema.serviceName, getRelativePath(schema.importModulePath, schema, 'service'));
}
return tree;
};
}
function buildAlain(schema) {
return (tree) => __awaiter(this, void 0, void 0, function* () {
const res = yield (0, workspace_1.getProject)(tree, schema.project);
if (schema.project && res.name !== schema.project) {
throw new schematics_1.SchematicsException(`The specified project does not match '${schema.project}', current: ${res.name}`);
}
const project = res.project;
resolveSchema(tree, project, schema, res.alainProject);
schema.componentName = buildName(schema, 'Component');
schema.serviceName = buildName(schema, 'Service');
// Don't support inline
schema.inlineTemplate = false;
const templateSource = (0, schematics_1.apply)((0, schematics_1.url)(schema._filesPath), [
(0, schematics_1.filter)(filePath => !filePath.endsWith('.DS_Store')),
schema.service === 'ignore' ? (0, schematics_1.filter)(filePath => !filePath.endsWith('.service.ts.template')) : (0, | {
ret.push(projectPrefix);
} | conditional_block |
alain.js | ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildAlain = exports.addValueToVariable = exports.addProviderToModule = exports.addImportToModule = exports.refreshPathRoot = void 0;
const core_1 = require("@angular-devkit/core");
const schematics_1 = require("@angular-devkit/schematics");
const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
const change_1 = require("@schematics/angular/utility/change");
const find_module_1 = require("@schematics/angular/utility/find-module");
const parse_name_1 = require("@schematics/angular/utility/parse-name");
const validation_1 = require("@schematics/angular/utility/validation");
const fs = require("fs");
const path = require("path");
const ts = require("typescript");
const ast_1 = require("./ast");
const workspace_1 = require("./workspace");
const TEMPLATE_FILENAME_RE = /\.template$/;
function buildSelector(schema, projectPrefix) {
const ret = [];
if (!schema.withoutPrefix) {
if (schema.prefix) {
ret.push(schema.prefix);
}
else if (schema.prefix === undefined && projectPrefix) {
ret.push(projectPrefix);
}
}
// module name
if (schema.module) {
ret.push(schema.module);
}
// target name
if (schema.target) {
ret.push(...schema.target.split('/'));
}
// name
ret.push(core_1.strings.dasherize(schema.name));
return ret.join('-');
}
function buildName(schema, prefix) {
const ret = schema.withoutModulePrefixInComponentName === true ? [] : [schema.module];
if (schema.target && schema.target.length > 0) {
ret.push(...schema.target.split('/'));
}
ret.push(schema.name);
// 服务类自动过滤 list, empty 两个页面的后缀
if (prefix === 'Service' && ['list', 'empty'].includes(schema.name)) {
ret.pop();
}
ret.push(prefix);
return core_1.strings.classify(ret.join('-'));
}
function refreshPathRoot(project, schema, alainProject) {
var _a;
if (schema.path === undefined) {
schema.path = `/${path.join(project.sourceRoot, (_a = alainProject === null || alainProject === void 0 ? void 0 : alainProject.routesRoot) !== null && _a !== void 0 ? _a : 'app/routes')}`;
}
}
exports.refreshPathRoot = refreshPathRoot;
function resolveSchema(tree, project, schema, alainProject) {
// module name
if (!schema.module) {
throw new schematics_1.SchematicsException(`Must specify module name. (e.g: ng g ng-alain:list <list name> -m=<module name>)`);
}
// path
refreshPathRoot(project, schema, alainProject);
schema.path += `/${schema.module}`;
const parsedPath = (0, parse_name_1.parseName)(schema.path, schema.name);
schema.name = parsedPath.name;
schema.path = parsedPath.path;
const rootPath = path.resolve(__dirname, '../../..');
const fullPath = path.join(rootPath, schema.path, schema.name);
if (fs.existsSync(fullPath) && fs.readdirSync(fullPath).length > 0) {
throw new schematics_1.SchematicsException(`The directory (${fullPath}) already exists`);
}
schema.importModulePath = (0, find_module_1.findModuleFromOptions)(tree, schema);
if (!schema._filesPath) {
// 若基础页尝试从 `_cli-tpl/_${schema.schematicName!}` 下查找该目录，若存在则优先使用
if (['list', 'edit', 'view', 'empty'].includes(schema.schematicName)) {
const overrideDir = `/${[project.root, `_cli-tpl/_${schema.schematicName}`].filter(i => !!i).join('/')}`;
const overridePath = `${overrideDir}/__path__/__name@dasherize@if-flat__/__name@dasherize__.component.ts`;
if (tree.exists(overridePath) || tree.exists(`${overridePath}.template`)) {
// 所在目录与命令目录同属一个目录结构，因此无须特殊处理
schema._filesPath = path.relative(__dirname, rootPath) + overrideDir;
}
}
schema._filesPath = schema._filesPath || './files';
}
// fill target
if (schema.target) {
schema.path += core_1.strings.dasherize(`/${schema.target}`);
}
schema.routerModulePath = schema.importModulePath.replace('.module.ts', '-routing.module.ts');
// html selector
schema.selector = schema.selector || buildSelector(schema, project.prefix);
(0, validation_1.validateHtmlSelector)(schema.selector);
}
function addImportToModule(tree, filePath, symbolName, fileName) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const change = (0, ast_utils_1.insertImport)(source, filePath, symbolName, fileName);
if (change.path == null)
return;
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addImportToModule = addImportToModule;
function addProviderToModule(tree, filePath, serviceName, importPath) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const changes = (0, ast_utils_1.addProviderToModule)(source, filePath, serviceName, importPath);
const declarationRecorder = tree.beginUpdate(filePath);
changes.forEach(change => {
if (change.path == null)
return;
if (change instanceof change_1.InsertChange) {
declarationRecorder.insertLeft(change.pos, change.toAdd);
}
});
tree.commitUpdate(declarationRecorder);
}
exports.addProviderToModule = addProviderToModule;
function addValueToVariable(tree, filePath, variableName, text, needWrap = true) {
const source = (0, ast_1.getSourceFile)(tree, filePath);
const node = (0, ast_utils_1.findNode)(source, ts.SyntaxKind.Identifier, variableName);
if (!node) {
throw new schematics_1.SchematicsException(`Could not find any [${variableName}] variable in path '${filePath}'.`);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const arr = node.parent.initializer;
const change = new change_1.InsertChange(filePath, arr.end - 1, `${arr.elements && arr.elements.length > 0 ? ',' : ''}${needWrap ? '\n ' : ''}${text}`);
const declarationRecorder = tree.beginUpdate(filePath);
declarationRecorder.insertLeft(change.pos, change.toAdd);
tree.commitUpdate(declarationRecorder);
}
exports.addValueToVariable = addValueToVariable;
function getRelativePath(filePath, schema, prefix) {
const importPath = `/${schema.path}/${schema.flat ? '' : `${core_1.strings.dasherize(schema.name)}/`}${core_1.strings.dasherize(schema.name)}.${prefix}`;
return (0, find_module_1.buildRelativePath)(filePath, importPath);
}
function addDeclaration(schema) {
return (tree) => {
if (schema.skipImport || !schema.module) {
return tree;
}
// imports
addImportToModule(tree, schema.importModulePath, schema.componentName, getRelativePath(schema.importModulePath, schema, 'component'));
addValueToVariable(tree, schema.importModulePath, 'COMPONENTS', schema.componentName);
// component
if (schema.modal !== true) {
// routing
addImportToModule(tree, schema.routerModulePath, schema.componentName, getRelativePath(schema.routerModulePath, schema, 'component'));
addValueToVariable(tree, schema.routerModulePath, 'routes', `{ path: '${schema.name}', component: ${schema.componentName} }`);
}
// service
if (schema.service === 'none') {
addProviderToModule(tree, schema.importModulePath, schema.serviceName, getRelativePath(schema.importModulePath, schema, 'service'));
}
return tree;
};
}
function buildAlain(schema) {
return (tree) => __awaiter(this, void 0, void 0, function* () {
const res = yield (0, workspace_1.getProject)(tree, schema.project);
if (schema.project && res.name !== schema.project) {
throw new schematics_1.SchematicsException(`The specified project does not match '${schema.project}', current: ${res.name}`);
}
const project = res.project;
resolveSchema(tree, project, schema, res.alainProject);
schema.componentName = buildName(schema, 'Component');
schema.serviceName = buildName(schema, 'Service'); | schema.service === 'ignore' ? (0, schematics_1.filter)(filePath => !filePath.endsWith('.service.ts.template')) : (0, schematics | // Don't support inline
schema.inlineTemplate = false;
const templateSource = (0, schematics_1.apply)((0, schematics_1.url)(schema._filesPath), [
(0, schematics_1.filter)(filePath => !filePath.endsWith('.DS_Store')), | random_line_split |
plot.py | .png')
# Display to screen
plt.show()
def | (_band, _period):
"""
Plots an observed band using pyplot
:param _band: Array to be plotted
:param _period: Period of object
"""
# Frequency = 1 / Period
_freq = 1 / _period
_xfit, _lobf = calclobf(_band, _period)
# Plot the data in the array to screen, lightly coloured and z rank behind the line of best fit
plt.style.use('seaborn-whitegrid')
plt.errorbar((_band[:, 0] * _freq) % 1, _band[:, 1], _band[:, 2], fmt='.', color='gray',
ecolor='lightgray', capsize=0, zorder=0)
# Plot the graph of the line of best fit
plt.plot(_xfit, _lobf, '-k', lw=2, zorder=2)
# Set x-axis limits to 1 period
plt.xlim(0, 1)
# Set graph and axis titles
plt.xlabel("Phase")
plt.ylabel("Magnitude")
plt.title("Folded light curve")
# Invert y-axis as convention
plt.gca().invert_yaxis()
# Display to screen
plt.show()
def calclobf(_band, _period):
"""
Creates a line of best fit using Lomb-Scargle methods
:param _inputband: Band array to be fit
:param _period: Period of object
:return: Returns a linearly spaced x-axis, with y-axis values for line of best fit
"""
# Create a model with 10 terms
_ls = LombScargle(_band[:, 0], _band[:, 1], _band[:, 2], nterms=10)
# Create n linearly spaced points between phase 0 and 1
_xfit = np.linspace(0, 1, 1000)
# Frequency = 1 / Period
_freq = 1 / _period
# Plot the line of best fit generated
_lobf = _ls.model(_xfit / _freq, _freq)
return _xfit, _lobf
def foldcurve(_band, _period):
"""
Folds the magnitude measurements to a light curve using provided period
:param _band: Observation band to be folded
:param _period: Period of object
:return: Array same size as _band, but with a phase instead of Julian date
"""
# Set epoch to first date observed
_epoch = _band[0][0]
# Iterate through array, update date to phase
for i in range(0, _band.shape[0]):
_band[i, 0] = ((_band[i, 0] - _epoch) / _period) % 1
# Return folded array
return _band
def doublearrayphase(_inputarray):
"""
Doubles a band array from phase 0 -> 1 to 0 -> 2 as convention
:param _inputarray: Array to be doubled
:return: Returns an array from phase 0 -> 2, size [n * 2, 3]
"""
# Create a new array twice the size of the input
_newarray = np.zeros((_inputarray.shape[0] * 2, _inputarray.shape[1]), dtype=float)
# Iterate through the input array
for i in range(0, _newarray.shape[0]):
# Before phase 1 simply copy data into new array
if i < _inputarray.shape[0]:
_newarray[i] = _inputarray[i]
# After phase 1, simply shift all phases by +1
else:
_newarray[i] = _inputarray[i - _inputarray.shape[0]]
_newarray[i][0] = _newarray[i][0] + 1
# Return the new doubled array
return _newarray
def plotblackbody(_zband, _yband, _jband, _hband, _kband, _parallax, _perr):
"""
Determines the black body curve and determines mass, radius and luminosities in solar units
:param _zband: Observed z-band
:param _yband: Observed y-band
:param _jband: Observed j-band
:param _hband: Observed h-band
:param _kband: Observed k-band
:param _parallax: Parallax angle (mas)
:param _perr: Parallax angle error (mas)
"""
# Set pyplot style to be consistent within the program
plt.style.use('seaborn-whitegrid')
# Import raw data to plot Hertzsprung-Russell diagram
_hrdata = inithr('hr.dat')
# Determine distance in parsecs
_distance = 1 / np.tan(_parallax * 10**-3)
_derr = (_perr * 10**-3) / ((_parallax * 10**-3)**2)
# Create single data array with all bands
_bands = [_zband, _yband, _jband, _hband, _kband]
_lambda = [0.9, 1.02, 1.22, 1.63, 2.2]
# Set up empty arrays for each star
_largestar = np.zeros((1, 2))
_smallstar = np.zeros((1, 2))
# Determine the spectral flux density from the large star
i = 0
while i < 5:
# Determine the maximum and minimum values of the observed band
_max, _min = lightcurve.maxminvals(_bands[i])
# The large star uses the maximum flux value (smallest magnitude)
_largestar = np.append(_largestar, np.array([_lambda[i], (magtoflux(_min, i))], ndmin=2), axis=0)
i += 1
# Delete first empty row of the array
_largestar = np.delete(_largestar, 0, axis=0)
# Determine the spectral flux density from the small star
i = 0
while i < 5:
# Determine the maximum and minimum values of the observed band
_max, _min = lightcurve.maxminvals(_bands[i])
# Smaller star flux value is combined value minus the large star
_smallstar = np.append(_smallstar, np.array([_lambda[i], (magtoflux(_max, i) -
magtoflux(_min, i))], ndmin=2), axis=0)
i += 1
# Delete the first empty row of the array
_smallstar = np.delete(_smallstar, 0, axis=0)
# Determine the luminosity and effective temperature of each star
_luma, _lumaerr, _wiena = getwientemp(_largestar, _distance, _derr, 1)
_lumb, _lumberr, _wienb = getwientemp(_smallstar, _distance, _derr, 2)
# Calculate luminosities in solar units
_solluma = _luma / (3.828*10**26)
_sollumb = _lumb / (3.828*10**26)
_lumaerr = _lumaerr / (3.828*10**26)
_lumberr = _lumberr / (3.828*10**26)
# Calculate masses using the mass/luminosity relation in solar mass units
# N.B. only works as an approximation for main sequence stars, giants and dwarfs are not sutiable for this
# approximation
_solmassa = np.power(_solluma, 1/3.5)
_solmassaerr = ((_solmassa * (1/3.5) * _lumaerr) / _solluma)**2
_solmassb = np.power(_sollumb, 1/3.5)
_solmassberr = ((_solmassb * (1 / 3.5) * _lumberr) / _sollumb) ** 2
# Calculate stellar radius in solar radii using the relationship between luminosity, surface area and temperature
_solrada = np.sqrt(_solluma / np.power(_wiena / 5778, 4))
_solradb = np.sqrt(_sollumb / np.power(_wienb / 5778, 4))
_solradaerr = ((_solrada * 0.5 * _lumaerr) / _solluma)**2
_solradberr = ((_solradb * 0.5 * _lumberr) / _sollumb)**2
# Output determined values to the screen and write to file
print('Values for the large star:')
print('Effective temperature: ' + str(round | plotband | identifier_name |
plot.py | first empty row of the array
_smallstar = np.delete(_smallstar, 0, axis=0)
# Determine the luminosity and effective temperature of each star
_luma, _lumaerr, _wiena = getwientemp(_largestar, _distance, _derr, 1)
_lumb, _lumberr, _wienb = getwientemp(_smallstar, _distance, _derr, 2)
# Calculate luminosities in solar units
_solluma = _luma / (3.828*10**26)
_sollumb = _lumb / (3.828*10**26)
_lumaerr = _lumaerr / (3.828*10**26)
_lumberr = _lumberr / (3.828*10**26)
# Calculate masses using the mass/luminosity relation in solar mass units
# N.B. only works as an approximation for main sequence stars, giants and dwarfs are not sutiable for this
# approximation
_solmassa = np.power(_solluma, 1/3.5)
_solmassaerr = ((_solmassa * (1/3.5) * _lumaerr) / _solluma)**2
_solmassb = np.power(_sollumb, 1/3.5)
_solmassberr = ((_solmassb * (1 / 3.5) * _lumberr) / _sollumb) ** 2
# Calculate stellar radius in solar radii using the relationship between luminosity, surface area and temperature
_solrada = np.sqrt(_solluma / np.power(_wiena / 5778, 4))
_solradb = np.sqrt(_sollumb / np.power(_wienb / 5778, 4))
_solradaerr = ((_solrada * 0.5 * _lumaerr) / _solluma)**2
_solradberr = ((_solradb * 0.5 * _lumberr) / _sollumb)**2
# Output determined values to the screen and write to file
print('Values for the large star:')
print('Effective temperature: ' + str(round_sig(_wiena)))
print('Solar luminosities: ' + str(round_sig(_solluma)) + ', error: ' + str(round_sig(_lumaerr)))
print('Solar radii: ' + str(round_sig(_solrada)) + ', error: ' + str(round_sig(_solradaerr)))
print('Solar masses: ' + str(round_sig(_solmassa)) + ', error: ' + str(round_sig(_solmassaerr)))
print('-----------------------------------------------------')
print('Values for the small star:')
print('Effective temperature: ' + str(round_sig(_wienb)))
print('Solar luminosities: ' + str(round_sig(_sollumb)) + ', error: ' + str(round_sig(_lumberr)))
print('Solar radii: ' + str(round_sig(_solradb)) + ', error: ' + str(round_sig(_solradberr)))
print('Solar masses: ' + str(round_sig(_solmassb)) + ', error: ' + str(round_sig(_solmassberr)))
# Convert from luminosity to magnitude in solar units
_luma = -2.5 * np.log10(_luma / (3.0128 * 10**28))
_lumb = -2.5 * np.log10(_lumb / (3.0128 * 10**28))
# Plot Hertzsprung-Russell diagram using provided array
plt.scatter(_hrdata[:, 1], _hrdata[:, 0], s=0.5)
# Plot determined values for each star
plt.scatter(_wiena, _luma, s=16, c='red', label='Larger Star')
plt.scatter(_wienb, _lumb, s=16, c='green', label='Smaller Star')
# Set the x and y axis limits to sensible values
plt.legend()
plt.xlim(3000, 10000)
plt.ylim(-10, 20)
# Invert both axes as convention
plt.gca().invert_xaxis()
plt.gca().invert_yaxis()
# Save figure to current folder
plt.savefig('hr.png')
# Display to screen
plt.show()
def getwientemp(_inputdata, _distance, _derr, _id):
"""
Determines the effective temperature using Wien's law
:param _inputdata: Black body curve of object
:param _distance: Distance to object (parsecs)
:param _id: 1 for large star, 2 for small star
:return: Luminosity and effective surface temperature
"""
# Maxwell-Boltzmann distribution formula probability density function
def curve(_x, _a, _scale):
_a1 = np.sqrt(2 / np.pi)
_a2 = _x**2 / (2 * _a**2)
return _scale * _a1 * (_x**2 * np.exp(-_a2)) / _a**3
# Set pyplot style to be consistent through the program
plt.style.use('seaborn-whitegrid')
# Convert the distance in parsecs to metres
_distance = 3.0857 * 10**16 * _distance
_derr = 3.0857 * 10**16 * _derr
# Create array for x and y axis data
_xdata = _inputdata[:, 0]
_ydata = _inputdata[:, 1]
_ydatalum = _ydata
# Iterate through each band and convert from Janskys to W/m^2/um
i = 0
while i < 5:
_ydata[i] = 3*10**14 * (_ydata[i] * 10**-26) / (Wavelength[i]**2)
i += 1
# Calculate optimal values and covariance using scipy curve_fit function
_popt, _pcov = curve_fit(curve, _xdata, _ydata)
# Create x axis to plot curve against
_x = np.linspace(0, 5, 100)
# Determine y value for each point on the x axis
_yplot = curve(_x, *_popt)
# Plot the curve to the screen
plt.plot(_x, _yplot)
# Determine the area under the graph, integral gives total energy recieved per m^2
_area = np.trapz(_yplot, dx=5/100)
# Total luminosity found by multiplying by the surface area of a sphere with diameter of the distance
_lum = 4 * np.pi * _distance**2 * _area
_lumerr = 4 * np.pi * _distance * _derr * _area
# Peak value of Maxwell-Boltzmann distribution
_mu = 2 * _popt[0] * np.sqrt(2 / np.pi)
# Plot data on the graph
plt.plot(_xdata, _ydata, '.')
# Set axis labels
plt.xlabel('Wavelength (um)')
plt.ylabel('Spectral Irradiance (W m^-2 um^-1)')
if _id == 1:
_str = 'Large Star'
else:
_str = 'Small Star'
# Calculate effective surface temperature using Wien's law
_wien = round_sig(2898 / _mu)
# Round luminosity to 2 significant figures
_lum = round_sig(_lum)
# Set graph title
plt.suptitle('Black Body Plot for the ' + _str)
# Save to current folder
_filename = _str + '.png'
plt.savefig(_filename)
# Display to the screen
plt.show()
# Returns calculated values
return _lum, _lumerr, _wien
def inithr(_filename):
"""
Parses required data for plotting a Hertzsprung-Russell diagram
:param _filename: File containing observed data
:return: (n x 3) size array containing magnitude, effective temperature and parallax angle
"""
# Open file provided
_file = open(_filename)
# Create empty array to hold data
_data = np.zeros((1, 3), dtype=float)
# Iterate through the file line by line | for _line in _file:
# Split each line into constituent values
_x = _line.split()
# Append data array with each value, converted to float, convert parallax angle to distance
_data = np.append(_data, np.array([float(_x[1]), float(_x[2]), (1 / float(_x[3]))], ndmin=2), axis=0) | random_line_split |
|
plot.py | .png')
# Display to screen
plt.show()
def plotband(_band, _period):
"""
Plots an observed band using pyplot
:param _band: Array to be plotted
:param _period: Period of object
"""
# Frequency = 1 / Period
_freq = 1 / _period
_xfit, _lobf = calclobf(_band, _period)
# Plot the data in the array to screen, lightly coloured and z rank behind the line of best fit
plt.style.use('seaborn-whitegrid')
plt.errorbar((_band[:, 0] * _freq) % 1, _band[:, 1], _band[:, 2], fmt='.', color='gray',
ecolor='lightgray', capsize=0, zorder=0)
# Plot the graph of the line of best fit
plt.plot(_xfit, _lobf, '-k', lw=2, zorder=2)
# Set x-axis limits to 1 period
plt.xlim(0, 1)
# Set graph and axis titles
plt.xlabel("Phase")
plt.ylabel("Magnitude")
plt.title("Folded light curve")
# Invert y-axis as convention
plt.gca().invert_yaxis()
# Display to screen
plt.show()
def calclobf(_band, _period):
"""
Creates a line of best fit using Lomb-Scargle methods
:param _inputband: Band array to be fit
:param _period: Period of object
:return: Returns a linearly spaced x-axis, with y-axis values for line of best fit
"""
# Create a model with 10 terms
_ls = LombScargle(_band[:, 0], _band[:, 1], _band[:, 2], nterms=10)
# Create n linearly spaced points between phase 0 and 1
_xfit = np.linspace(0, 1, 1000)
# Frequency = 1 / Period
_freq = 1 / _period
# Plot the line of best fit generated
_lobf = _ls.model(_xfit / _freq, _freq)
return _xfit, _lobf
def foldcurve(_band, _period):
"""
Folds the magnitude measurements to a light curve using provided period
:param _band: Observation band to be folded
:param _period: Period of object
:return: Array same size as _band, but with a phase instead of Julian date
"""
# Set epoch to first date observed
_epoch = _band[0][0]
# Iterate through array, update date to phase
for i in range(0, _band.shape[0]):
_band[i, 0] = ((_band[i, 0] - _epoch) / _period) % 1
# Return folded array
return _band
def doublearrayphase(_inputarray):
"""
Doubles a band array from phase 0 -> 1 to 0 -> 2 as convention
:param _inputarray: Array to be doubled
:return: Returns an array from phase 0 -> 2, size [n * 2, 3]
"""
# Create a new array twice the size of the input
_newarray = np.zeros((_inputarray.shape[0] * 2, _inputarray.shape[1]), dtype=float)
# Iterate through the input array
for i in range(0, _newarray.shape[0]):
# Before phase 1 simply copy data into new array
if i < _inputarray.shape[0]:
_newarray[i] = _inputarray[i]
# After phase 1, simply shift all phases by +1
else:
_newarray[i] = _inputarray[i - _inputarray.shape[0]]
_newarray[i][0] = _newarray[i][0] + 1
# Return the new doubled array
return _newarray
def plotblackbody(_zband, _yband, _jband, _hband, _kband, _parallax, _perr):
"""
Determines the black body curve and determines mass, radius and luminosities in solar units
:param _zband: Observed z-band
:param _yband: Observed y-band
:param _jband: Observed j-band
:param _hband: Observed h-band
:param _kband: Observed k-band
:param _parallax: Parallax angle (mas)
:param _perr: Parallax angle error (mas)
"""
# Set pyplot style to be consistent within the program
plt.style.use('seaborn-whitegrid')
# Import raw data to plot Hertzsprung-Russell diagram
_hrdata = inithr('hr.dat')
# Determine distance in parsecs
_distance = 1 / np.tan(_parallax * 10**-3)
_derr = (_perr * 10**-3) / ((_parallax * 10**-3)**2)
# Create single data array with all bands
_bands = [_zband, _yband, _jband, _hband, _kband]
_lambda = [0.9, 1.02, 1.22, 1.63, 2.2]
# Set up empty arrays for each star
_largestar = np.zeros((1, 2))
_smallstar = np.zeros((1, 2))
# Determine the spectral flux density from the large star
i = 0
while i < 5:
# Determine the maximum and minimum values of the observed band
|
# Delete first empty row of the array
_largestar = np.delete(_largestar, 0, axis=0)
# Determine the spectral flux density from the small star
i = 0
while i < 5:
# Determine the maximum and minimum values of the observed band
_max, _min = lightcurve.maxminvals(_bands[i])
# Smaller star flux value is combined value minus the large star
_smallstar = np.append(_smallstar, np.array([_lambda[i], (magtoflux(_max, i) -
magtoflux(_min, i))], ndmin=2), axis=0)
i += 1
# Delete the first empty row of the array
_smallstar = np.delete(_smallstar, 0, axis=0)
# Determine the luminosity and effective temperature of each star
_luma, _lumaerr, _wiena = getwientemp(_largestar, _distance, _derr, 1)
_lumb, _lumberr, _wienb = getwientemp(_smallstar, _distance, _derr, 2)
# Calculate luminosities in solar units
_solluma = _luma / (3.828*10**26)
_sollumb = _lumb / (3.828*10**26)
_lumaerr = _lumaerr / (3.828*10**26)
_lumberr = _lumberr / (3.828*10**26)
# Calculate masses using the mass/luminosity relation in solar mass units
# N.B. only works as an approximation for main sequence stars, giants and dwarfs are not sutiable for this
# approximation
_solmassa = np.power(_solluma, 1/3.5)
_solmassaerr = ((_solmassa * (1/3.5) * _lumaerr) / _solluma)**2
_solmassb = np.power(_sollumb, 1/3.5)
_solmassberr = ((_solmassb * (1 / 3.5) * _lumberr) / _sollumb) ** 2
# Calculate stellar radius in solar radii using the relationship between luminosity, surface area and temperature
_solrada = np.sqrt(_solluma / np.power(_wiena / 5778, 4))
_solradb = np.sqrt(_sollumb / np.power(_wienb / 5778, 4))
_solradaerr = ((_solrada * 0.5 * _lumaerr) / _solluma)**2
_solradberr = ((_solradb * 0.5 * _lumberr) / _sollumb)**2
# Output determined values to the screen and write to file
print('Values for the large star:')
print('Effective temperature: ' + str(round_sig(_ | _max, _min = lightcurve.maxminvals(_bands[i])
# The large star uses the maximum flux value (smallest magnitude)
_largestar = np.append(_largestar, np.array([_lambda[i], (magtoflux(_min, i))], ndmin=2), axis=0)
i += 1 | conditional_block |
plot.py |
def plotallbands(_zband, _yband, _jband, _hband, _kband, _period):
"""
Plots all observed bands to the same graph
:param _zband: Observed z-band
:param _yband: Observed y-band
:param _jband: Observed j-band
:param _hband: Observed h-band
:param _kband: Observed k-band
:param _period: Period of variability
"""
# Set pyplot style to be consisten within the program
plt.style.use('seaborn-whitegrid')
# Frequency = 1 / Period
_freq = 1 / _period
# Create single dataset from all bands
_bands = [_zband, _yband, _jband, _hband, _kband]
# Iterate through each band and plot to screen
i = 0
while i < 5:
# Array to set colours for each band
_colours = ['-b', '-g', '-r', '-c', '-m']
# Array to set strings for graph legend
_legend = ['Z-band', 'Y-band', 'J-band', 'H-band', 'K-band']
# Determine the line of best fit for each band
_xfit, _lobf = calclobf(_bands[i], _period)
# Plot the data in the array to screen, lightly coloured and z rank behind the line of best fit
plt.plot(_xfit, _lobf, _colours[i], lw=1, zorder=2, label=_legend[i])
i += 1
# Set x-axis limit to a single period
plt.xlim(0, 1)
# Set graph and axis titles
plt.xlabel("Phase")
plt.ylabel("Magnitude")
plt.title("Folded light curve")
# Show the legend
plt.legend()
# Invert y-axis as convention
plt.gca().invert_yaxis()
# Save to current folder
plt.savefig('curve.png')
# Display to screen
plt.show()
def plotband(_band, _period):
"""
Plots an observed band using pyplot
:param _band: Array to be plotted
:param _period: Period of object
"""
# Frequency = 1 / Period
_freq = 1 / _period
_xfit, _lobf = calclobf(_band, _period)
# Plot the data in the array to screen, lightly coloured and z rank behind the line of best fit
plt.style.use('seaborn-whitegrid')
plt.errorbar((_band[:, 0] * _freq) % 1, _band[:, 1], _band[:, 2], fmt='.', color='gray',
ecolor='lightgray', capsize=0, zorder=0)
# Plot the graph of the line of best fit
plt.plot(_xfit, _lobf, '-k', lw=2, zorder=2)
# Set x-axis limits to 1 period
plt.xlim(0, 1)
# Set graph and axis titles
plt.xlabel("Phase")
plt.ylabel("Magnitude")
plt.title("Folded light curve")
# Invert y-axis as convention
plt.gca().invert_yaxis()
# Display to screen
plt.show()
def calclobf(_band, _period):
"""
Creates a line of best fit using Lomb-Scargle methods
:param _inputband: Band array to be fit
:param _period: Period of object
:return: Returns a linearly spaced x-axis, with y-axis values for line of best fit
"""
# Create a model with 10 terms
_ls = LombScargle(_band[:, 0], _band[:, 1], _band[:, 2], nterms=10)
# Create n linearly spaced points between phase 0 and 1
_xfit = np.linspace(0, 1, 1000)
# Frequency = 1 / Period
_freq = 1 / _period
# Plot the line of best fit generated
_lobf = _ls.model(_xfit / _freq, _freq)
return _xfit, _lobf
def foldcurve(_band, _period):
"""
Folds the magnitude measurements to a light curve using provided period
:param _band: Observation band to be folded
:param _period: Period of object
:return: Array same size as _band, but with a phase instead of Julian date
"""
# Set epoch to first date observed
_epoch = _band[0][0]
# Iterate through array, update date to phase
for i in range(0, _band.shape[0]):
_band[i, 0] = ((_band[i, 0] - _epoch) / _period) % 1
# Return folded array
return _band
def doublearrayphase(_inputarray):
"""
Doubles a band array from phase 0 -> 1 to 0 -> 2 as convention
:param _inputarray: Array to be doubled
:return: Returns an array from phase 0 -> 2, size [n * 2, 3]
"""
# Create a new array twice the size of the input
_newarray = np.zeros((_inputarray.shape[0] * 2, _inputarray.shape[1]), dtype=float)
# Iterate through the input array
for i in range(0, _newarray.shape[0]):
# Before phase 1 simply copy data into new array
if i < _inputarray.shape[0]:
_newarray[i] = _inputarray[i]
# After phase 1, simply shift all phases by +1
else:
_newarray[i] = _inputarray[i - _inputarray.shape[0]]
_newarray[i][0] = _newarray[i][0] + 1
# Return the new doubled array
return _newarray
def plotblackbody(_zband, _yband, _jband, _hband, _kband, _parallax, _perr):
"""
Determines the black body curve and determines mass, radius and luminosities in solar units
:param _zband: Observed z-band
:param _yband: Observed y-band
:param _jband: Observed j-band
:param _hband: Observed h-band
:param _kband: Observed k-band
:param _parallax: Parallax angle (mas)
:param _perr: Parallax angle error (mas)
"""
# Set pyplot style to be consistent within the program
plt.style.use('seaborn-whitegrid')
# Import raw data to plot Hertzsprung-Russell diagram
_hrdata = inithr('hr.dat')
# Determine distance in parsecs
_distance = 1 / np.tan(_parallax * 10**-3)
_derr = (_perr * 10**-3) / ((_parallax * 10**-3)**2)
# Create single data array with all bands
_bands = [_zband, _yband, _jband, _hband, _kband]
_lambda = [0.9, 1.02, 1.22, 1.63, 2.2]
# Set up empty arrays for each star
_largestar = np.zeros((1, 2))
_smallstar = np.zeros((1, 2))
# Determine the spectral flux density from the large star
i = 0
while i < 5:
# Determine the maximum and minimum values of the observed band
_max, _min = lightcurve.maxminvals(_bands[i])
# The large star uses the maximum flux value (smallest magnitude)
_largestar = np.append(_largestar, np.array([_lambda[i], (magtoflux(_min, i))], ndmin=2), axis=0)
i += 1
# Delete first empty row of the array
_largestar = np.delete(_largestar, 0, axis=0)
# Determine the spectral flux density from the small star
i = 0
while i < 5:
# Determine the maximum and minimum values of the observed band
_max, _min = lightcurve.maxminvals(_bands[i])
# Smaller star flux value is combined value minus the large star
_smallstar = np.append(_smallstar, np.array([_lambda[i], (magtoflux(_max, i) -
magtoflux(_min, i))], ndmin=2), axis=0)
i += 1
# Delete the first empty row of the array
_smallstar = np.delete(_small | """
Rounds the provided value to 2 significant figures
:param _val: Value to be rounded
:return: Float, original value rounded to 2 significant figures
"""
return round(_val, 3 - int(floor(log10(abs(_val)))) - 1) | identifier_body |
|
routing.rs | nodes, we know our incoming edges have already been updated to point to the egress nodes.
let mut ingresses = HashMap::new();
for node in topo_list {
let domain = graph[node].domain();
// First, we add egress nodes for any of our cross-domain children
let children: Vec<_> = graph.neighbors_directed(node, petgraph::EdgeDirection::Outgoing)
.collect(); // collect so we can mutate graph
// We then need to make sure that we're acting on up-to-date information about existing
// egress/ingress pairs. In particular, we want to know about egresses this node already
// has (and to which domains). In the process we also populate the information about
// ingress nodes in other domains that point here (those shouldn't be re-created if new
// nodes are created in the corresponding domains).
let mut egresses = HashMap::new();
for child in &children {
if !new.contains(child) {
continue;
}
if let node::Type::Egress { .. } = *graph[*child] {
for ingress in graph.neighbors_directed(*child, petgraph::EdgeDirection::Outgoing) {
// this egress already contains this node to the ingress' domain
egresses.insert(graph[ingress].domain(), *child);
// also keep track of the corresponding ingress node so we can re-use it
ingresses.entry(graph[ingress].domain())
.or_insert_with(HashMap::new)
.insert(node, ingress);
}
}
}
for child in children {
let cdomain = graph[child].domain();
if domain != cdomain {
// child is in a different domain
if !egresses.contains_key(&cdomain) {
// create an egress node to handle that
// NOTE: technically, this doesn't need to mirror its parent, but meh
let proxy = graph[node].mirror(node::Type::Egress {
tags: Default::default(),
txs: Default::default(),
});
let egress = graph.add_node(proxy);
graph.add_edge(node, egress, false);
new.insert(egress);
egresses.insert(cdomain, egress);
trace!(log, "adding cross-domain egress to new node"; "node" => node.index(), "egress" => egress.index());
} else {
trace!(log, "re-using cross-domain egress to new node"; "node" => node.index(), "egress" => egresses[&cdomain].index());
}
// we need to hook that node in between us and this child
let egress = egresses[&cdomain];
let old = graph.find_edge(node, child).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(egress, child, was_materialized);
// this ends up being re-executed, but that's okay
swaps.entry(cdomain).or_insert_with(HashMap::new).insert(node, egress);
}
}
// Then, we look for any parents in the graph that
//
// a) are in a different domain, and
// b) aren't egress nodes
//
// This situation arises whenever a cross-domain edge is added as the result of a
// migration. We need to find or make an egress domain in that other domain, and hook that
// up as the parent of this node instead of the original internal foreign domain node.
//
// Note that same-domain parents are never interesting to us for this purpose.
let mut parents: Vec<_> = graph.neighbors_directed(node, petgraph::EdgeDirection::Incoming)
.filter(|&ni| ni == source || graph[ni].domain() != domain)
.collect(); // collect so we can mutate graph
for parent in &mut parents {
if *parent == source {
// no egress needed
continue;
}
// since we are traversing in topological order, egress nodes should have been added to
// all our parents, and our incoming edges should have been updated. if that *isn't*
// the case for a given parent, it must be a pre-existing parent.
if let node::Type::Egress { .. } = *graph[*parent] {
continue;
}
// let's first see if this parent already has an egress we can use
let egress = graph.neighbors_directed(*parent, petgraph::EdgeDirection::Outgoing)
.find(|&ni| graph[ni].is_egress());
let egress = egress.unwrap_or_else(|| {
// no, okay, so we need to add an egress for that other node,
let proxy = graph[*parent].mirror(node::Type::Egress{
txs: Default::default(),
tags: Default::default()
});
let egress = graph.add_node(proxy);
trace!(log, "adding cross-domain egress to existing node"; "node" => parent.index(), "egress" => egress.index());
graph.add_edge(*parent, egress, false);
new.insert(egress);
egress
});
// now, let's use that egress as our parent instead
let old = graph.find_edge(*parent, node).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(egress, node, was_materialized);
// all references to our original parent should now refer to the egress
swaps.entry(domain).or_insert_with(HashMap::new).insert(*parent, egress);
// and we should now just consider the egress our parent instead
*parent = egress;
}
// Now that we know all our foreign parents are egress nodes, we can add ingress nodes.
// Note that by this time (due to the topological walk), we know that `ingresses` has been
// sufficiently populated to contain any relevant existing ingress nodes.
for parent in parents {
// is there already an ingress node we can re-use?
let mut ingress =
ingresses.get(&domain).and_then(|ingresses| ingresses.get(&parent)).map(|ni| *ni);
if ingress.is_none() {
// nope -- create our new ingress node
let mut i = graph[parent].mirror(node::Type::Ingress);
i.add_to(domain); // it belongs to this domain, not that of the parent
let i = graph.add_node(i);
graph.add_edge(parent, i, false);
// we also now need to deal with this ingress node
new.insert(i);
if parent == source {
trace!(log, "adding source ingress"; "base" => node.index(), "ingress" => i.index());
// we don't re-use source ingress nodes
} else {
trace!(log, "adding cross-domain ingress"; "to" => node.index(), "from" => parent.index(), "ingress" => i.index());
ingresses.entry(domain).or_insert_with(HashMap::new).insert(parent, i);
}
ingress = Some(i);
} else {
trace!(log, "re-using cross-domain ingress"; "to" => node.index(), "from" => parent.index(), "ingress" => ingress.unwrap().index());
}
let ingress = ingress.unwrap();
// we need to hook the ingress node in between us and the parent
let old = graph.find_edge(parent, node).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(ingress, node, was_materialized);
// tracking swaps here is a bit tricky because we've already swapped the "true" parents
// of `node` with the ids of the egress nodes. thus, we actually need to do swaps on
// the values in `swaps`, not insert new entries (that, or we'd need to change the
// resolution process to be recursive, which is painful and unnecessary). note that we
// *also* need to special-case handing base nodes, because there there *won't* be a
// parent egress swap
if parent != source {
for (_, to) in swaps.get_mut(&domain).unwrap().iter_mut() {
if *to == parent {
*to = ingress;
}
}
}
}
}
swaps
}
pub fn connect(log: &Logger,
graph: &mut Graph,
main_txs: &HashMap<domain::Index, mpsc::SyncSender<Packet>>,
new: &HashSet<NodeIndex>) | {
// ensure all egress nodes contain the tx channel of the domains of their child ingress nodes
for &node in new {
let n = &graph[node];
if let node::Type::Ingress = **n {
// check the egress connected to this ingress
} else {
continue;
}
for egress in graph.neighbors_directed(node, petgraph::EdgeDirection::Incoming) {
match *graph[egress] {
node::Type::Egress { ref txs, .. } => {
trace!(log, "connecting"; "egress" => egress.index(), "ingress" => node.index());
txs.lock()
.unwrap()
.push((node.into(), n.addr(), main_txs[&n.domain()].clone()));
continue;
} | identifier_body |
|
routing.rs | *graph);
while let Some(node) = topo.next(&*graph) {
if node == source {
continue;
}
if !new.contains(&node) {
continue;
}
topo_list.push(node);
}
// we need to keep track of all the times we change the parent of a node (by replacing it with
// an egress, and then with an ingress), since this remapping must be communicated to the nodes
// so they know the true identifier of their parent in the graph.
let mut swaps = HashMap::new();
// we also need to keep track of the ingress nodes we've added to each domain so that we don't
// end up with two ingress nodes for a given egress node. that would cause unnecessary
// cross-domain communication. this is domain => source => NodeIndex (of ingress). note that
// `source` here is actually the *egress* node. this is because by the time we add ingress
// nodes, we know our incoming edges have already been updated to point to the egress nodes.
let mut ingresses = HashMap::new();
for node in topo_list {
let domain = graph[node].domain();
// First, we add egress nodes for any of our cross-domain children
let children: Vec<_> = graph.neighbors_directed(node, petgraph::EdgeDirection::Outgoing)
.collect(); // collect so we can mutate graph
// We then need to make sure that we're acting on up-to-date information about existing
// egress/ingress pairs. In particular, we want to know about egresses this node already
// has (and to which domains). In the process we also populate the information about
// ingress nodes in other domains that point here (those shouldn't be re-created if new
// nodes are created in the corresponding domains).
let mut egresses = HashMap::new();
for child in &children {
if !new.contains(child) {
continue;
}
if let node::Type::Egress { .. } = *graph[*child] {
for ingress in graph.neighbors_directed(*child, petgraph::EdgeDirection::Outgoing) {
// this egress already contains this node to the ingress' domain
egresses.insert(graph[ingress].domain(), *child);
// also keep track of the corresponding ingress node so we can re-use it
ingresses.entry(graph[ingress].domain())
.or_insert_with(HashMap::new)
.insert(node, ingress);
}
}
}
for child in children {
let cdomain = graph[child].domain();
if domain != cdomain {
// child is in a different domain
if !egresses.contains_key(&cdomain) {
// create an egress node to handle that
// NOTE: technically, this doesn't need to mirror its parent, but meh
let proxy = graph[node].mirror(node::Type::Egress {
tags: Default::default(),
txs: Default::default(),
});
let egress = graph.add_node(proxy);
graph.add_edge(node, egress, false);
new.insert(egress);
egresses.insert(cdomain, egress);
trace!(log, "adding cross-domain egress to new node"; "node" => node.index(), "egress" => egress.index());
} else {
trace!(log, "re-using cross-domain egress to new node"; "node" => node.index(), "egress" => egresses[&cdomain].index());
}
// we need to hook that node in between us and this child
let egress = egresses[&cdomain];
let old = graph.find_edge(node, child).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(egress, child, was_materialized);
// this ends up being re-executed, but that's okay
swaps.entry(cdomain).or_insert_with(HashMap::new).insert(node, egress);
}
}
// Then, we look for any parents in the graph that
//
// a) are in a different domain, and
// b) aren't egress nodes
//
// This situation arises whenever a cross-domain edge is added as the result of a
// migration. We need to find or make an egress domain in that other domain, and hook that
// up as the parent of this node instead of the original internal foreign domain node.
//
// Note that same-domain parents are never interesting to us for this purpose.
let mut parents: Vec<_> = graph.neighbors_directed(node, petgraph::EdgeDirection::Incoming)
.filter(|&ni| ni == source || graph[ni].domain() != domain)
.collect(); // collect so we can mutate graph
for parent in &mut parents {
if *parent == source {
// no egress needed
continue;
}
// since we are traversing in topological order, egress nodes should have been added to
// all our parents, and our incoming edges should have been updated. if that *isn't*
// the case for a given parent, it must be a pre-existing parent.
if let node::Type::Egress { .. } = *graph[*parent] {
continue;
}
// let's first see if this parent already has an egress we can use
let egress = graph.neighbors_directed(*parent, petgraph::EdgeDirection::Outgoing)
.find(|&ni| graph[ni].is_egress());
let egress = egress.unwrap_or_else(|| {
// no, okay, so we need to add an egress for that other node,
let proxy = graph[*parent].mirror(node::Type::Egress{
txs: Default::default(),
tags: Default::default()
});
let egress = graph.add_node(proxy);
trace!(log, "adding cross-domain egress to existing node"; "node" => parent.index(), "egress" => egress.index());
graph.add_edge(*parent, egress, false);
new.insert(egress);
egress
});
// now, let's use that egress as our parent instead
let old = graph.find_edge(*parent, node).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(egress, node, was_materialized);
// all references to our original parent should now refer to the egress
swaps.entry(domain).or_insert_with(HashMap::new).insert(*parent, egress);
// and we should now just consider the egress our parent instead
*parent = egress;
}
// Now that we know all our foreign parents are egress nodes, we can add ingress nodes.
// Note that by this time (due to the topological walk), we know that `ingresses` has been
// sufficiently populated to contain any relevant existing ingress nodes.
for parent in parents {
// is there already an ingress node we can re-use?
let mut ingress =
ingresses.get(&domain).and_then(|ingresses| ingresses.get(&parent)).map(|ni| *ni);
if ingress.is_none() {
// nope -- create our new ingress node
let mut i = graph[parent].mirror(node::Type::Ingress);
i.add_to(domain); // it belongs to this domain, not that of the parent
let i = graph.add_node(i);
graph.add_edge(parent, i, false);
// we also now need to deal with this ingress node
new.insert(i);
if parent == source {
trace!(log, "adding source ingress"; "base" => node.index(), "ingress" => i.index());
// we don't re-use source ingress nodes
} else {
trace!(log, "adding cross-domain ingress"; "to" => node.index(), "from" => parent.index(), "ingress" => i.index());
ingresses.entry(domain).or_insert_with(HashMap::new).insert(parent, i);
}
ingress = Some(i);
} else {
trace!(log, "re-using cross-domain ingress"; "to" => node.index(), "from" => parent.index(), "ingress" => ingress.unwrap().index());
}
let ingress = ingress.unwrap();
// we need to hook the ingress node in between us and the parent
let old = graph.find_edge(parent, node).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(ingress, node, was_materialized);
// tracking swaps here is a bit tricky because we've already swapped the "true" parents
// of `node` with the ids of the egress nodes. thus, we actually need to do swaps on
// the values in `swaps`, not insert new entries (that, or we'd need to change the
// resolution process to be recursive, which is painful and unnecessary). note that we
// *also* need to special-case handing base nodes, because there there *won't* be a
// parent egress swap
if parent != source {
for (_, to) in swaps.get_mut(&domain).unwrap().iter_mut() {
if *to == parent {
*to = ingress;
}
}
}
}
}
swaps
}
pub fn | connect | identifier_name |
|
routing.rs | domain::Index, HashMap<NodeIndex, NodeIndex>> {
// find all new nodes in topological order. we collect first since we'll be mutating the graph
// below. it's convenient to have the nodes in topological order, because we then know that
// we'll first add egress nodes, and then the related ingress nodes. if we're ever required to
// add an ingress node, and its parent isn't an egress node, we know that we're seeing a
// connection between an old node in one domain, and a new node in a different domain.
let mut topo_list = Vec::with_capacity(new.len());
let mut topo = petgraph::visit::Topo::new(&*graph);
while let Some(node) = topo.next(&*graph) {
if node == source {
continue;
}
if !new.contains(&node) {
continue;
}
topo_list.push(node);
}
// we need to keep track of all the times we change the parent of a node (by replacing it with
// an egress, and then with an ingress), since this remapping must be communicated to the nodes
// so they know the true identifier of their parent in the graph.
let mut swaps = HashMap::new();
// we also need to keep track of the ingress nodes we've added to each domain so that we don't
// end up with two ingress nodes for a given egress node. that would cause unnecessary
// cross-domain communication. this is domain => source => NodeIndex (of ingress). note that
// `source` here is actually the *egress* node. this is because by the time we add ingress
// nodes, we know our incoming edges have already been updated to point to the egress nodes.
let mut ingresses = HashMap::new();
for node in topo_list {
let domain = graph[node].domain();
// First, we add egress nodes for any of our cross-domain children
let children: Vec<_> = graph.neighbors_directed(node, petgraph::EdgeDirection::Outgoing)
.collect(); // collect so we can mutate graph
// We then need to make sure that we're acting on up-to-date information about existing
// egress/ingress pairs. In particular, we want to know about egresses this node already
// has (and to which domains). In the process we also populate the information about
// ingress nodes in other domains that point here (those shouldn't be re-created if new
// nodes are created in the corresponding domains).
let mut egresses = HashMap::new();
for child in &children {
if !new.contains(child) {
continue;
}
if let node::Type::Egress { .. } = *graph[*child] {
for ingress in graph.neighbors_directed(*child, petgraph::EdgeDirection::Outgoing) {
// this egress already contains this node to the ingress' domain
egresses.insert(graph[ingress].domain(), *child);
// also keep track of the corresponding ingress node so we can re-use it
ingresses.entry(graph[ingress].domain())
.or_insert_with(HashMap::new)
.insert(node, ingress);
}
}
}
for child in children {
let cdomain = graph[child].domain();
if domain != cdomain {
// child is in a different domain
if !egresses.contains_key(&cdomain) {
// create an egress node to handle that
// NOTE: technically, this doesn't need to mirror its parent, but meh
let proxy = graph[node].mirror(node::Type::Egress {
tags: Default::default(),
txs: Default::default(),
});
let egress = graph.add_node(proxy);
graph.add_edge(node, egress, false);
new.insert(egress);
egresses.insert(cdomain, egress);
trace!(log, "adding cross-domain egress to new node"; "node" => node.index(), "egress" => egress.index());
} else {
trace!(log, "re-using cross-domain egress to new node"; "node" => node.index(), "egress" => egresses[&cdomain].index());
}
// we need to hook that node in between us and this child
let egress = egresses[&cdomain];
let old = graph.find_edge(node, child).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(egress, child, was_materialized);
// this ends up being re-executed, but that's okay
swaps.entry(cdomain).or_insert_with(HashMap::new).insert(node, egress);
}
}
// Then, we look for any parents in the graph that
//
// a) are in a different domain, and
// b) aren't egress nodes
//
// This situation arises whenever a cross-domain edge is added as the result of a
// migration. We need to find or make an egress domain in that other domain, and hook that
// up as the parent of this node instead of the original internal foreign domain node.
//
// Note that same-domain parents are never interesting to us for this purpose.
let mut parents: Vec<_> = graph.neighbors_directed(node, petgraph::EdgeDirection::Incoming)
.filter(|&ni| ni == source || graph[ni].domain() != domain)
.collect(); // collect so we can mutate graph
for parent in &mut parents {
if *parent == source {
// no egress needed
continue;
}
// since we are traversing in topological order, egress nodes should have been added to
// all our parents, and our incoming edges should have been updated. if that *isn't*
// the case for a given parent, it must be a pre-existing parent.
if let node::Type::Egress { .. } = *graph[*parent] {
continue;
}
// let's first see if this parent already has an egress we can use
let egress = graph.neighbors_directed(*parent, petgraph::EdgeDirection::Outgoing)
.find(|&ni| graph[ni].is_egress());
let egress = egress.unwrap_or_else(|| {
// no, okay, so we need to add an egress for that other node,
let proxy = graph[*parent].mirror(node::Type::Egress{
txs: Default::default(),
tags: Default::default()
});
let egress = graph.add_node(proxy);
trace!(log, "adding cross-domain egress to existing node"; "node" => parent.index(), "egress" => egress.index());
graph.add_edge(*parent, egress, false);
new.insert(egress);
egress
});
// now, let's use that egress as our parent instead
let old = graph.find_edge(*parent, node).unwrap();
let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(egress, node, was_materialized);
// all references to our original parent should now refer to the egress
swaps.entry(domain).or_insert_with(HashMap::new).insert(*parent, egress);
// and we should now just consider the egress our parent instead
*parent = egress;
}
// Now that we know all our foreign parents are egress nodes, we can add ingress nodes.
// Note that by this time (due to the topological walk), we know that `ingresses` has been
// sufficiently populated to contain any relevant existing ingress nodes.
for parent in parents {
// is there already an ingress node we can re-use?
let mut ingress =
ingresses.get(&domain).and_then(|ingresses| ingresses.get(&parent)).map(|ni| *ni);
if ingress.is_none() {
// nope -- create our new ingress node
let mut i = graph[parent].mirror(node::Type::Ingress);
i.add_to(domain); // it belongs to this domain, not that of the parent
let i = graph.add_node(i);
graph.add_edge(parent, i, false);
// we also now need to deal with this ingress node
new.insert(i);
if parent == source {
trace!(log, "adding source ingress"; "base" => node.index(), "ingress" => i.index());
// we don't re-use source ingress nodes
} else {
trace!(log, "adding cross-domain ingress"; "to" => node.index(), "from" => parent.index(), "ingress" => i.index());
ingresses.entry(domain).or_insert_with(HashMap::new).insert(parent, i);
}
ingress = Some(i);
} else {
trace!(log, "re-using cross-domain ingress"; "to" => node.index(), "from" => parent.index(), "ingress" => ingress.unwrap().index());
}
let ingress = ingress.unwrap();
// we need to hook the ingress node in between us and the parent
let old = graph.find_edge(parent, node).unwrap(); | let was_materialized = graph.remove_edge(old).unwrap();
graph.add_edge(ingress, node, was_materialized);
// tracking swaps here is a bit tricky because we've already swapped the "true" parents | random_line_split |
|
main.rs | *response.body_mut() = Body::wrap_stream(stream_fuck);
//*response.body_mut() = Body::empty();
//*response.set_body(Box::new(stream));
// type BoxFut = Box<Future<Item = Response<Body>, Error = hyper::Error> + Send>;
//let future_result = future::ok(response);
// let mut buf = BytesMut::with_capacity(1024);
// buf.put(&b"hello world"[..]);
//let mut response1 = Response::new("Fuck");
// let mut response1 = Response::new(Body::from(buf.freeze()));
// let future_result: FutureResult<Response<Body>, hyper::Error> = future::ok(response1);
//return Box::new( future_result);
//let (method, uri, version, headers, body) = req.deconstruct();
let myresp =
chunk::handle_request(Request::new(Body::from("Fuck ya to chunk::handle_request")));
return Box::new(myresp);
//let future_result: FutureResult<Response<Body>, hyper::Error> = future::ok(response);
//return Box::new(future_result);
}
// Simply echo the body back to the client.
(&Method::POST, "/echo") => {
*response.body_mut() = req.into_body();
}
//(&Method::GET, Some("/fwd/")) => {
// *response.body_mut() = Body::from("Jahahahahaha");
//}
// Convert to uppercase before sending back to client.
(&Method::POST, "/echo/uppercase") => {
let mapping = req.into_body().map(|chunk| {
chunk
.iter()
.map(|byte| byte.to_ascii_uppercase())
.collect::<Vec<u8>>()
});
*response.body_mut() = Body::wrap_stream(mapping);
}
// Reverse the entire body before sending back to the client.
//
// Since we don't know the end yet, we can't simply stream
// the chunks as they arrive. So, this returns a different
// future, waiting on concatenating the full body, so that
// it can be reversed. Only then can we return a `Response`.
(&Method::POST, "/echo/reversed") => {
let reversed = req.into_body().concat2().map(move |chunk| {
let body = chunk.iter().rev().cloned().collect::<Vec<u8>>();
*response.body_mut() = Body::from(body);
response
});
return Box::new(reversed);
}
// The 404 Not Found route...
_ => {
println!("404 not found.");
*response.status_mut() = StatusCode::NOT_FOUND;
}
};
Box::new(future::ok(response))
}
/*struct ChunkDecoder;
impl Decoder for ChunkDecoder {
type Item = Chunk;
type Error = io::Error;
fn decode(&mut self, buf: &mut bytes::BytesMut) -> Result<Option<Chunk>, io::Error> {
let len = buf.len();
if len > 0 {
Ok(Some(buf.take().freeze().into()))
} else {
Ok(None)
}
}
}*/
struct MyStream {
current: u32,
max: u32,
}
impl MyStream {
pub fn new(max: u32) -> MyStream {
MyStream {
current: 0,
max: max,
}
}
}
impl Stream for MyStream {
type Item = u32;
type Error = Box<Error>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
match self.current {
ref mut x if *x < self.max => {
*x = *x + 1;
Ok(Async::Ready(Some(*x)))
}
_ => Ok(Async::Ready(None)),
}
}
}
/*fn get_local_mp3_path() -> &str {
//let mut f = File::open("./p.mp3").expect("failed to open mp3 file!");
let mut filepath = "/media/hdd/jedzia/rust/p.mp3";
if cfg!(target_os = "windows") {
filepath = "p.mp3";
}
filepath
}*/
fn main() -> Result<(), Box<dyn Error>> {
println!("Hello, lovely VU Duo!");
let y: f32 = 5.0;
if y < 4.0 {
// https://stackoverflow.com/questions/51550167/how-to-manually-return-a-result-boxerror
return Err("Bad request".into());
}
// http://192.168.2.43:3000/
//let addr = ([0, 0, 0, 0], 3000).into();
//let addr = ([127, 0, 0, 1], 3000).into();
//let addr = ([192, 168, 2, 43], 3000).into();
pretty_env_logger::init();
//fun_with_ssl();
//return Ok(());
/*
// helps when certificates are not found
extern crate openssl_probe;
let ssl = openssl_probe::init_ssl_cert_env_vars();
*/
//let mut buffer = String::new();
//f.read_to_string(&mut buffer)?;
//let in_addr: SocketAddr = ([127, 0, 0, 1], 3333).into();
let in_addr = get_in_addr();
/*let out_addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
// google.de 216.58.208.35
//let out_addr: SocketAddr = ([216, 58, 208, 35], 443).into();
let client_main = Client::new();
let out_addr_clone = out_addr.clone();
// new_service is run for each connection, creating a 'service'
// to handle requests for that specific connection.
let new_service = move || {
let client = client_main.clone();
// This is the `Service` that will handle the connection.
// `service_fn_ok` is a helper to convert a function that
// returns a Response into a `Service`.
service_fn(move |mut req| {
let uri_string = format!(
"http://{}/{}",
out_addr_clone,
req.uri().path_and_query().map(|x| x.as_str()).unwrap_or("")
);
let uri = uri_string.parse().unwrap();
let in_uri_string = format!("http://{}/{}", in_addr, req.uri());
let in_remove_string = format!("http://{}//", in_addr);
println!("req.uri(): {}", in_uri_string);
let result = in_uri_string.replace(&in_remove_string, "");
//let result = in_uri_string.split(in_remove_string.unwrap_or("")).take(1).next().unwrap_or("");
println!("result: {}", result);
*req.uri_mut() = uri;
client.request(req)
})
};
let server = Server::bind(&in_addr)
.serve(new_service)
.map_err(|e| eprintln!("server error: {}", e));
println!("Listening on http://{}", in_addr);
println!("Proxying on http://{}", out_addr);
rt::run(server);*/
//let mut f = File::open("p.mp3")?;
//let mut buffer: Vec<u8> = Vec::new();
//f.read_to_end(&mut buffer)?;
//let b = buffer.clone();
let server = Server::bind(&in_addr)
//.serve(|| service_fn(|req| echo(req, Vec::new())))
.serve(|| service_fn(echo))
.map_err(|e| eprintln!("server error: {}", e));
println!("Listening on http://{}", in_addr);
hyper::rt::run(server);
println!("finished.");
Ok(())
}
/*//#cfg!(target_os = "windows")
fn testOpenSSL1() {
extern crate openssl;
use openssl::rsa::{Padding, Rsa};
let rsa = Rsa::generate(2048).unwrap();
let data = b"foobar";
println!("data {:?}", data);
let mut buf = vec![0; rsa.size() as usize];
let encrypted_len = rsa.public_encrypt(data, &mut buf, Padding::PKCS1).unwrap();
println!("encripted {:?}", buf);
}*/
fn testOpenSSL() | {
/* extern crate openssl;
println!("===== testOpenSSL =====");
use openssl::ssl::{SslConnector, SslMethod};
use std::io::{Read, Write};
use std::net::TcpStream;
let connector = SslConnector::builder(SslMethod::tls()).unwrap().build();
let stream = TcpStream::connect("google.com:443").unwrap();
let mut stream = connector.connect("google.com", stream).unwrap();
stream.write_all(b"GET / HTTP/1.0\r\n\r\n").unwrap();
let mut res = vec![];
stream.read_to_end(&mut res).unwrap();
println!(
"{}",
String::from_utf8_lossy(&res)
.lines() | identifier_body |
|
main.rs | (uri: &Uri) -> String {
//let in_addr: SocketAddr = get_in_addr();
let uri_string = uri.path_and_query().map(|x| x.as_str()).unwrap_or("");
//let uri: String = uri_string.parse().unwrap();
//let in_uri_string = format!("http://{}/{}", in_addr, req.uri());
let in_remove_string = "/fwd/";
debug!("uri_string: {}", uri_string);
let result = uri_string.replace(&in_remove_string, "");
debug!("result: {}", result);
//let result = in_uri_string.split(in_remove_string.unwrap_or("")).take(1).next().unwrap_or("");
result
}
fn reformat_dates(before: &str) -> Cow<str> {
lazy_static! {
static ref ISO8601_DATE_REGEX : Regex = Regex::new(
//r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})"
//r"/^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i"
//r"(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i"
r"(https?://(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)*.(\.ogg))"
).unwrap();
}
ISO8601_DATE_REGEX.replace_all(before, "FUCK YA")
}
/// We need to return different futures depending on the route matched,
/// and we can do that with an enum, such as `futures::Either`, or with
/// trait objects.
///
/// A boxed Future (trait object) is used as it is easier to understand
/// and extend with more types. Advanced users could switch to `Either`.
type BoxFut = Box<Future<Item = Response<Body>, Error = hyper::Error> + Send>;
/// This is our service handler. It receives a Request, routes on its
/// path, and returns a Future of a Response.
//fn echo(req: Request<Body>, buf: Vec<u8>) -> BoxFut {
fn echo(req: Request<Body>) -> BoxFut {
let mut response = Response::new(Body::empty());
debug!("method: {}, uri: {}", req.method(), req.uri());
match req.method() {
&Method::GET => {
if req.uri().path().starts_with("/fwd/") {
let req_uri = reduce_forwarded_uri(req.uri());
//let forwarded_uri = Uri::from_static(&req_uri);
*response.body_mut() = Body::from("Lets forward: ".to_owned() + &req_uri);
let body = reqwest::get(req_uri.as_str()) //.unwrap();
//.danger_disable_certs_verification()
.expect(&format!("cannot get '{}'", &req_uri))
.text() //.unwrap();
.expect(&format!("cannot get text for '{}'", &req_uri));
/*let body = reqwest::Client::builder()
.danger_accept_invalid_hostnames(true)
.danger_accept_invalid_certs(true)
.build()
.unwrap()
.get("https://www.google.de/")
.send()
.unwrap()
.text()
.unwrap();*/
println!("body = {}", body.lines().take(3).collect::<String>());
/*let re_weburl = Regex::new(
r"/^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i"
);*/
// check if there is an alternative to the ogg-vorbis stream
// when true, then prioritize the mp3 over it
// else create a reference to the mp3 forwarding endpoint
// SSL Certificates on the host are important. make shure:
// ENV SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
// ENV SSL_CERT_DIR=/etc/ssl/certs
// are set.
let after = reformat_dates(&body);
//println!("body = {}", after);
//let chunk = Chunk::from(after);
//*response.body_mut() = Body::from(after.to_string());
*response.body_mut() = Body::from(after.to_string());
//*response.body_mut() = Body::from("got regex");
return Box::new(future::ok(response));
}
}
_ => {}
}
match (req.method(), req.uri().path()) {
// Serve some instructions at /
(&Method::GET, "/") => {
//command_name = 'ffmpeg',
//command_opts = ['-i', 'pipe:0', '-f', 'mp3', '-acodec', 'libvorbis', '-ab', '128k', '-aq', '60', '-f', 'ogg', '-'];
/*
let command_name = "ffmpeg";
//let command_opts = ["-i", "pipe:0", "-f", "mp3", "-acodec", "libvorbis", "-ab", "128k", "-aq", "60", "-f", "ogg", "-"];
//"D:\Program Files\ffmpeg\bin\ffmpeg" -re -i "https://cdn.netzpolitik.org/wp-upload/2019/02/NPP169-Worum-geht-es-eigentlich-bei-der-ePrivacy-Reform.ogg"
// -acodec libmp3lame -ab 128k -aq 6 | reduce_forwarded_uri | identifier_name |
|
main.rs | ut {
fn echo(req: Request<Body>) -> BoxFut {
let mut response = Response::new(Body::empty());
debug!("method: {}, uri: {}", req.method(), req.uri());
match req.method() {
&Method::GET => {
if req.uri().path().starts_with("/fwd/") {
let req_uri = reduce_forwarded_uri(req.uri());
//let forwarded_uri = Uri::from_static(&req_uri);
*response.body_mut() = Body::from("Lets forward: ".to_owned() + &req_uri);
let body = reqwest::get(req_uri.as_str()) //.unwrap();
//.danger_disable_certs_verification()
.expect(&format!("cannot get '{}'", &req_uri))
.text() //.unwrap();
.expect(&format!("cannot get text for '{}'", &req_uri));
/*let body = reqwest::Client::builder()
.danger_accept_invalid_hostnames(true)
.danger_accept_invalid_certs(true)
.build()
.unwrap()
.get("https://www.google.de/")
.send()
.unwrap()
.text()
.unwrap();*/
println!("body = {}", body.lines().take(3).collect::<String>());
/*let re_weburl = Regex::new(
r"/^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i"
);*/
// check if there is an alternative to the ogg-vorbis stream
// when true, then prioritize the mp3 over it
// else create a reference to the mp3 forwarding endpoint
// SSL Certificates on the host are important. make shure:
// ENV SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
// ENV SSL_CERT_DIR=/etc/ssl/certs
// are set.
let after = reformat_dates(&body);
//println!("body = {}", after);
//let chunk = Chunk::from(after);
//*response.body_mut() = Body::from(after.to_string());
*response.body_mut() = Body::from(after.to_string());
//*response.body_mut() = Body::from("got regex");
return Box::new(future::ok(response));
}
}
_ => {}
}
match (req.method(), req.uri().path()) {
// Serve some instructions at /
(&Method::GET, "/") => {
//command_name = 'ffmpeg',
//command_opts = ['-i', 'pipe:0', '-f', 'mp3', '-acodec', 'libvorbis', '-ab', '128k', '-aq', '60', '-f', 'ogg', '-'];
/*
let command_name = "ffmpeg";
//let command_opts = ["-i", "pipe:0", "-f", "mp3", "-acodec", "libvorbis", "-ab", "128k", "-aq", "60", "-f", "ogg", "-"];
//"D:\Program Files\ffmpeg\bin\ffmpeg" -re -i "https://cdn.netzpolitik.org/wp-upload/2019/02/NPP169-Worum-geht-es-eigentlich-bei-der-ePrivacy-Reform.ogg"
// -acodec libmp3lame -ab 128k -aq 60 -f mp3 - > bla.mp3
//let media_addr = "https://cdn.netzpolitik.org/wp-upload/2019/02/NPP169-Worum-geht-es-eigentlich-bei-der-ePrivacy-Reform.ogg";
let media_addr = "https://upload.wikimedia.org/wikipedia/commons/f/f2/Median_test.ogg";
let command_opts = ["-i", media_addr,
"-acodec", "libmp3lame", "-ab", "128k", "-aq", "60", "-f", "mp3", "-"];
let mut ffmpeg_path = command_name;
if cfg!(target_os = "windows") {
ffmpeg_path = "D:/Program Files/ffmpeg/bin/ffmpeg.exe";
}
// Spawn the `wc` command
let process = match Command::new(ffmpeg_path)
.args(&command_opts)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.spawn()
{
Err(why) => panic!("couldn't spawn {}: {}", command_name, why.description()),
Ok(process) => process,
};
// The `stdout` field also has type `Option<ChildStdout>` so must be unwrapped.
let mut buffer: Vec<u8> = Vec::new();
match process.stdout.unwrap().read_to_end(&mut buffer) {
Err(why) => panic!("couldn't read {} stdout: {}", command_name, why.description()),
Ok(_) => println!("buffer size:[{}]", buffer.len()),
}
*response.body_mut() = Body::from(buffer);
return Box::new( future::ok(response));
*/
/*let mapping = || -> Vec(u8)
{
}*/
//let chunks = vec!["hello", " ", "world"];
//let stream = futures::stream::iter_ok::<_, ::std::io::Error>(chunks);
/*let mapping = req
.into_body()
.map(|chunk| {
chunk.iter()
.map(|byte| byte.to_ascii_uppercase())
.collect::<Vec<u8>>()
});*/
let mapping1 = req.into_body().map(|chunk| {
chunk
.iter()
.map(|byte| {
println!("chunk {}", byte.to_ascii_uppercase());
byte.to_ascii_uppercase()
})
.collect::<Vec<u8>>()
});
let data_fuck = vec!["FUCK", " ", "YOU!"];
let chunk_fuck = Chunk::from("fuck");
let stream_fuck = futures::stream::iter_ok::<_, ::std::io::Error>(data_fuck);
/* //let data2 = vec!["hello", " ", "world"];
let data2: Vec<u8> = vec![0x55, 0x20, 0x66];
//let chunk2 = Chunk::from(data2);
//let conv = |x: Vec<u8>| x.iter();
let stream2 = futures::stream::iter_ok::<_, ::std::io::Error>(data2);
//let stream2 = futures::stream::iter_ok::<_, ::std::io::Error>(data2);
let chunks = fileio::load_local_mp3_buffer();
let c: &[u8] = &chunks; // c: &[u8]
//let chunk = Chunk::from(c);
let stream = futures::stream::iter_ok::<_, ::std::io::Error>(c);
*response.body_mut() = Body::from(chunks);
return Box::new( future::ok(response));
*/
// type BoxFut = Box<Future<Item = Response<Body>, Error = hyper::Error> + Send>;
//let bbb = Box::new(future::ok(Response::new("Fuck YOU")));
//let xxx: BoxFut = Box::new(future::ok(response));
//xxx
let my_stream = MyStream::new(5);
//let xstream = futures::stream::iter_ok::<_, ::std::io::Error>(my_stream.iter());
//let mut file = &get_local_mp3_path();
let mut filepath = "/media/hdd/jedzia/rust/p.mp3";
if cfg!(target_os = "windows") {
filepath = "p.mp3";
}
//let file = File::open(filepath).map(file_response).or_else(|_| status_response(StatusCode::NOT_FOUND));
//.expect("failed to open file")
//let file = tokio::fs::File::open(filepath).catch_unwind();
//let fstream = FramedRead::new(file, ChunkDecoder);
/*fn decode(buf: Vec<u8>) -> Result<Option<Chunk>, io::Error> {
let len = buf.len(); | random_line_split |
||
mod.rs | ::Always),
_ => Err("invalid cache policy"),
}
}
}
impl Default for CachePolicy {
fn default() -> Self {
CachePolicy::Auto
}
}
/// Options that configure the behavior of the passthrough fuse file system.
#[derive(Debug, Clone, PartialEq)]
pub struct Config {
/// How long the FUSE client should consider directory entries to be valid. If the contents of a
/// directory can only be modified by the FUSE client (i.e., the file system has exclusive
/// access), then this should be a large value.
///
/// The default value for this option is 5 seconds.
pub entry_timeout: Duration,
/// How long the FUSE client should consider file and directory attributes to be valid. If the
/// attributes of a file or directory can only be modified by the FUSE client (i.e., the file
/// system has exclusive access), then this should be set to a large value.
///
/// The default value for this option is 5 seconds.
pub attr_timeout: Duration,
/// The caching policy the file system should use. See the documentation of `CachePolicy` for
/// more details.
pub cache_policy: CachePolicy,
/// Whether the file system should enabled writeback caching. This can improve performance as it
/// allows the FUSE client to cache and coalesce multiple writes before sending them to the file
/// system. However, enabling this option can increase the risk of data corruption if the file
/// contents can change without the knowledge of the FUSE client (i.e., the server does **NOT**
/// have exclusive access). Additionally, the file system should have read access to all files
/// in the directory it is serving as the FUSE client may send read requests even for files
/// opened with `O_WRONLY`.
///
/// Therefore callers should only enable this option when they can guarantee that: 1) the file
/// system has exclusive access to the directory and 2) the file system has read permissions for
/// all files in that directory.
///
/// The default value for this option is `false`.
pub writeback: bool,
/// The path of the root directory.
///
/// The default is `/`.
pub root_dir: String,
/// Whether the file system should support Extended Attributes (xattr). Enabling this feature may
/// have a significant impact on performance, especially on write parallelism. This is the result
/// of FUSE attempting to remove the special file privileges after each write request.
///
/// The default value for this options is `false`.
pub xattr: bool,
/// To be compatible with Vfs and PseudoFs, PassthroughFs needs to prepare
/// root inode before accepting INIT request.
///
/// The default value for this option is `true`.
pub do_import: bool,
/// Control whether no_open is allowed.
///
/// The default value for this option is `false`.
pub no_open: bool,
/// Control whether no_opendir is allowed.
///
/// The default value for this option is `false`.
pub no_opendir: bool,
}
impl Default for Config {
fn default() -> Self {
Config {
entry_timeout: Duration::from_secs(5),
attr_timeout: Duration::from_secs(5),
cache_policy: Default::default(),
writeback: false,
root_dir: String::from("/"),
xattr: false,
do_import: true,
no_open: false,
no_opendir: false,
}
}
}
/// A file system that simply "passes through" all requests it receives to the underlying file
/// system.
///
/// To keep the implementation simple it servers the contents of its root directory. Users
/// that wish to serve only a specific directory should set up the environment so that that
/// directory ends up as the root of the file system process. One way to accomplish this is via a
/// combination of mount namespaces and the pivot_root system call.
pub struct PassthroughFs<D> {
// File descriptors for various points in the file system tree. These fds are always opened with
// the `O_PATH` option so they cannot be used for reading or writing any data. See the
// documentation of the `O_PATH` flag in `open(2)` for more details on what one can and cannot
// do with an fd opened with this flag.
inode_map: InodeMap,
next_inode: AtomicU64,
// File descriptors for open files and directories. Unlike the fds in `inodes`, these _can_ be
// used for reading and writing data.
handle_map: HandleMap,
next_handle: AtomicU64,
// File descriptor pointing to the `/proc` directory. This is used to convert an fd from
// `inodes` into one that can go into `handles`. This is accomplished by reading the
// `self/fd/{}` symlink. We keep an open fd here in case the file system tree that we are meant
// to be serving doesn't have access to `/proc`.
proc: File,
// Whether writeback caching is enabled for this directory. This will only be true when
// `cfg.writeback` is true and `init` was called with `FsOptions::WRITEBACK_CACHE`.
writeback: AtomicBool,
// Whether no_open is enabled.
no_open: AtomicBool,
// Whether no_opendir is enabled.
no_opendir: AtomicBool,
cfg: Config,
phantom: PhantomData<D>,
}
impl<D: AsyncDrive> PassthroughFs<D> {
/// Create a Passthrough file system instance.
pub fn new(cfg: Config) -> io::Result<PassthroughFs<D>> {
// Safe because this is a constant value and a valid C string.
let proc_cstr = unsafe { CStr::from_bytes_with_nul_unchecked(PROC_CSTR) };
let proc = Self::open_file(
libc::AT_FDCWD,
proc_cstr,
libc::O_PATH | libc::O_NOFOLLOW | libc::O_CLOEXEC,
0,
)?;
Ok(PassthroughFs {
inode_map: InodeMap::new(),
next_inode: AtomicU64::new(fuse::ROOT_ID + 1),
handle_map: HandleMap::new(),
next_handle: AtomicU64::new(1),
proc,
writeback: AtomicBool::new(false),
no_open: AtomicBool::new(false),
no_opendir: AtomicBool::new(false),
cfg,
phantom: PhantomData,
})
}
/// Initialize the Passthrough file system.
pub fn import(&self) -> io::Result<()> {
let root = CString::new(self.cfg.root_dir.as_str()).expect("CString::new failed");
// We use `O_PATH` because we just want this for traversing the directory tree
// and not for actually reading the contents.
let f = Self::open_file(
libc::AT_FDCWD,
&root,
libc::O_PATH | libc::O_NOFOLLOW | libc::O_CLOEXEC,
0,
)?;
let st = Self::stat(&f)?;
// Safe because this doesn't modify any memory and there is no need to check the return
// value because this system call always succeeds. We need to clear the umask here because
// we want the client to be able to set all the bits in the mode.
unsafe { libc::umask(0o000) };
// Not sure why the root inode gets a refcount of 2 but that's what libfuse does.
self.inode_map.insert(
fuse::ROOT_ID,
InodeAltKey::from_stat(&st),
InodeData::new(fuse::ROOT_ID, f, 2),
);
Ok(())
}
/// Get the list of file descriptors which should be reserved across live upgrade.
pub fn keep_fds(&self) -> Vec<RawFd> {
vec![self.proc.as_raw_fd()]
}
fn stat(f: &File) -> io::Result<libc::stat64> {
// Safe because this is a constant value and a valid C string.
let pathname = unsafe { CStr::from_bytes_with_nul_unchecked(EMPTY_CSTR) };
let mut st = MaybeUninit::<libc::stat64>::zeroed();
// Safe because the kernel will only write data in `st` and we check the return value.
let res = unsafe {
libc::fstatat64(
f.as_raw_fd(),
pathname.as_ptr(),
st.as_mut_ptr(),
libc::AT_EMPTY_PATH | libc::AT_SYMLINK_NOFOLLOW,
)
};
if res >= 0 {
// Safe because the kernel guarantees that the struct is now fully initialized.
Ok(unsafe { st.assume_init() })
} else {
Err(io::Error::last_os_error())
}
}
fn open_file(dfd: i32, pathname: &CStr, flags: i32, mode: u32) -> io::Result<File> {
let fd = if flags & libc::O_CREAT == libc::O_CREAT {
unsafe { libc::openat(dfd, pathname.as_ptr(), flags, mode) }
} else {
| unsafe { libc::openat(dfd, pathname.as_ptr(), flags) }
};
| conditional_block |
|
mod.rs | use std::mem::MaybeUninit;
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
use std::str::FromStr;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockWriteGuard};
use std::time::Duration;
use vm_memory::ByteValued;
use crate::abi::linux_abi as fuse;
use crate::api::filesystem::Entry;
use crate::api::{BackendFileSystem, VFS_MAX_INO};
#[cfg(feature = "async-io")]
mod async_io;
mod sync_io;
mod multikey;
use multikey::MultikeyBTreeMap;
use crate::async_util::AsyncDrive;
const CURRENT_DIR_CSTR: &[u8] = b".\0";
const PARENT_DIR_CSTR: &[u8] = b"..\0";
const EMPTY_CSTR: &[u8] = b"\0";
const PROC_CSTR: &[u8] = b"/proc\0";
type Inode = u64;
type Handle = u64;
#[derive(Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq)]
struct InodeAltKey {
ino: libc::ino64_t,
dev: libc::dev_t,
}
impl InodeAltKey {
fn from_stat(st: &libc::stat64) -> Self {
InodeAltKey {
ino: st.st_ino,
dev: st.st_dev,
}
}
}
struct InodeData {
inode: Inode,
// Most of these aren't actually files but ¯\_(ツ)_/¯.
file: File,
refcount: AtomicU64,
}
impl InodeData {
fn new(inode: Inode, file: File, refcount: u64) -> Self {
InodeData {
inode,
file,
refcount: AtomicU64::new(refcount),
}
}
// When making use of the underlying RawFd, the caller must ensure that the Arc<InodeData>
// object is within scope. Otherwise it may cause race window to access wrong target fd.
// By introducing this method, we could explicitly audit all callers making use of the
// underlying RawFd.
fn get_raw_fd(&self) -> RawFd {
self.file.as_raw_fd()
}
}
/// Data structures to manage accessed inodes.
struct InodeMap {
inodes: RwLock<MultikeyBTreeMap<Inode, InodeAltKey, Arc<InodeData>>>,
}
impl InodeMap {
fn new() -> Self {
InodeMap {
inodes: RwLock::new(MultikeyBTreeMap::new()),
}
}
fn clear(&self) {
self.inodes.write().unwrap().clear();
}
fn get(&self, inode: Inode) -> io::Result<Arc<InodeData>> {
self.inodes
.read()
.unwrap()
.get(&inode)
.map(Arc::clone)
.ok_or_else(ebadf)
}
fn get_alt(&self, altkey: &InodeAltKey) -> Option<Arc<InodeData>> {
self.inodes.read().unwrap().get_alt(altkey).map(Arc::clone)
}
fn get_map_mut(
&self,
) -> RwLockWriteGuard<MultikeyBTreeMap<Inode, InodeAltKey, Arc<InodeData>>> {
self.inodes.write().unwrap()
}
fn insert(&self, inode: Inode, altkey: InodeAltKey, data: InodeData) {
self.inodes
.write()
.unwrap()
.insert(inode, altkey, Arc::new(data));
}
}
struct HandleData {
inode: Inode,
file: File,
lock: Mutex<()>,
}
impl HandleData {
fn new(inode: Inode, file: File) -> Self {
HandleData {
inode,
file,
lock: Mutex::new(()),
}
}
fn get_file_mut(&self) -> (MutexGuard<()>, &File) {
(self.lock.lock().unwrap(), &self.file)
}
// When making use of the underlying RawFd, the caller must ensure that the Arc<HandleData>
// object is within scope. Otherwise it may cause race window to access wrong target fd.
// By introducing this method, we could explicitly audit all callers making use of the
// underlying RawFd.
fn get_handle_raw_fd(&self) -> RawFd {
self.file.as_raw_fd()
}
}
struct HandleMap {
handles: RwLock<BTreeMap<Handle, Arc<HandleData>>>,
}
impl HandleMap {
fn new() -> Self {
HandleMap {
handles: RwLock::new(BTreeMap::new()),
}
}
fn clear(&self) {
self.handles.write().unwrap().clear();
}
fn insert(&self, handle: Handle, data: HandleData) {
self.handles.write().unwrap().insert(handle, Arc::new(data));
}
fn release(&self, handle: Handle, inode: Inode) -> io::Result<()> {
let mut handles = self.handles.write().unwrap();
if let btree_map::Entry::Occupied(e) = handles.entry(handle) {
if e.get().inode == inode {
// We don't need to close the file here because that will happen automatically when
// the last `Arc` is dropped.
e.remove();
return Ok(());
}
}
Err(ebadf())
}
fn get(&self, handle: Handle, inode: Inode) -> io::Result<Arc<HandleData>> {
self.handles
.read()
.unwrap()
.get(&handle)
.filter(|hd| hd.inode == inode)
.map(Arc::clone)
.ok_or_else(ebadf)
}
}
#[repr(C, packed)]
#[derive(Clone, Copy, Debug, Default)]
struct LinuxDirent64 {
d_ino: libc::ino64_t,
d_off: libc::off64_t,
d_reclen: libc::c_ushort,
d_ty: libc::c_uchar,
}
unsafe impl ByteValued for LinuxDirent64 {}
/// The caching policy that the file system should report to the FUSE client. By default the FUSE
/// protocol uses close-to-open consistency. This means that any cached contents of the file are
/// invalidated the next time that file is opened.
#[derive(Debug, Clone, PartialEq)]
pub enum CachePolicy {
/// The client should never cache file data and all I/O should be directly forwarded to the
/// server. This policy must be selected when file contents may change without the knowledge of
/// the FUSE client (i.e., the file system does not have exclusive access to the directory).
Never,
/// The client is free to choose when and how to cache file data. This is the default policy and
/// uses close-to-open consistency as described in the enum documentation.
Auto,
/// The client should always cache file data. This means that the FUSE client will not
/// invalidate any cached data that was returned by the file system the last time the file was
/// opened. This policy should only be selected when the file system has exclusive access to the
/// directory.
Always,
}
impl FromStr for CachePolicy {
type Err = &'static str;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"never" | "Never" | "NEVER" | "none" | "None" | "NONE" => Ok(CachePolicy::Never),
"auto" | "Auto" | "AUTO" => Ok(CachePolicy::Auto),
"always" | "Always" | "ALWAYS" => Ok(CachePolicy::Always),
_ => Err("invalid cache policy"),
}
}
}
impl Default for CachePolicy {
fn default() -> Self {
CachePolicy::Auto
}
}
/// Options that configure the behavior of the passthrough fuse file system.
#[derive(Debug, Clone, PartialEq)]
pub struct Config {
/// How long the FUSE client should consider directory entries to be valid. If the contents of a
/// directory can only be modified by the FUSE client (i.e., the file system has exclusive
/// access), then this should be a large value.
///
/// The default value for this option is 5 seconds.
pub entry_timeout: Duration,
/// How long the FUSE client should consider file and directory attributes to be valid. If the
/// attributes of a file or directory can only be modified by the FUSE client (i.e., the file
/// system has exclusive access), then this should be set to a large value.
///
/// The default value for this option is 5 seconds.
pub attr_timeout: Duration,
/// The caching policy the file system should use. See the documentation of `CachePolicy` for
/// more details.
pub cache_policy: CachePolicy,
/// Whether the file system should enabled writeback caching. This can improve performance as it
| use std::ffi::{CStr, CString};
use std::fs::File;
use std::io;
use std::marker::PhantomData; | random_line_split |
|
mod.rs | fd from
// `inodes` into one that can go into `handles`. This is accomplished by reading the
// `self/fd/{}` symlink. We keep an open fd here in case the file system tree that we are meant
// to be serving doesn't have access to `/proc`.
proc: File,
// Whether writeback caching is enabled for this directory. This will only be true when
// `cfg.writeback` is true and `init` was called with `FsOptions::WRITEBACK_CACHE`.
writeback: AtomicBool,
// Whether no_open is enabled.
no_open: AtomicBool,
// Whether no_opendir is enabled.
no_opendir: AtomicBool,
cfg: Config,
phantom: PhantomData<D>,
}
impl<D: AsyncDrive> PassthroughFs<D> {
/// Create a Passthrough file system instance.
pub fn new(cfg: Config) -> io::Result<PassthroughFs<D>> {
// Safe because this is a constant value and a valid C string.
let proc_cstr = unsafe { CStr::from_bytes_with_nul_unchecked(PROC_CSTR) };
let proc = Self::open_file(
libc::AT_FDCWD,
proc_cstr,
libc::O_PATH | libc::O_NOFOLLOW | libc::O_CLOEXEC,
0,
)?;
Ok(PassthroughFs {
inode_map: InodeMap::new(),
next_inode: AtomicU64::new(fuse::ROOT_ID + 1),
handle_map: HandleMap::new(),
next_handle: AtomicU64::new(1),
proc,
writeback: AtomicBool::new(false),
no_open: AtomicBool::new(false),
no_opendir: AtomicBool::new(false),
cfg,
phantom: PhantomData,
})
}
/// Initialize the Passthrough file system.
pub fn import(&self) -> io::Result<()> {
let root = CString::new(self.cfg.root_dir.as_str()).expect("CString::new failed");
// We use `O_PATH` because we just want this for traversing the directory tree
// and not for actually reading the contents.
let f = Self::open_file(
libc::AT_FDCWD,
&root,
libc::O_PATH | libc::O_NOFOLLOW | libc::O_CLOEXEC,
0,
)?;
let st = Self::stat(&f)?;
// Safe because this doesn't modify any memory and there is no need to check the return
// value because this system call always succeeds. We need to clear the umask here because
// we want the client to be able to set all the bits in the mode.
unsafe { libc::umask(0o000) };
// Not sure why the root inode gets a refcount of 2 but that's what libfuse does.
self.inode_map.insert(
fuse::ROOT_ID,
InodeAltKey::from_stat(&st),
InodeData::new(fuse::ROOT_ID, f, 2),
);
Ok(())
}
/// Get the list of file descriptors which should be reserved across live upgrade.
pub fn keep_fds(&self) -> Vec<RawFd> {
vec![self.proc.as_raw_fd()]
}
fn stat(f: &File) -> io::Result<libc::stat64> {
// Safe because this is a constant value and a valid C string.
let pathname = unsafe { CStr::from_bytes_with_nul_unchecked(EMPTY_CSTR) };
let mut st = MaybeUninit::<libc::stat64>::zeroed();
// Safe because the kernel will only write data in `st` and we check the return value.
let res = unsafe {
libc::fstatat64(
f.as_raw_fd(),
pathname.as_ptr(),
st.as_mut_ptr(),
libc::AT_EMPTY_PATH | libc::AT_SYMLINK_NOFOLLOW,
)
};
if res >= 0 {
// Safe because the kernel guarantees that the struct is now fully initialized.
Ok(unsafe { st.assume_init() })
} else {
Err(io::Error::last_os_error())
}
}
fn open_file(dfd: i32, pathname: &CStr, flags: i32, mode: u32) -> io::Result<File> {
let fd = if flags & libc::O_CREAT == libc::O_CREAT {
unsafe { libc::openat(dfd, pathname.as_ptr(), flags, mode) }
} else {
unsafe { libc::openat(dfd, pathname.as_ptr(), flags) }
};
if fd < 0 {
return Err(io::Error::last_os_error());
}
// Safe because we just opened this fd.
Ok(unsafe { File::from_raw_fd(fd) })
}
fn do_lookup(&self, parent: Inode, name: &CStr) -> io::Result<Entry> {
let p = self.inode_map.get(parent)?;
let f = Self::open_file(
p.get_raw_fd(),
name,
libc::O_PATH | libc::O_NOFOLLOW | libc::O_CLOEXEC,
0,
)?;
let st = Self::stat(&f)?;
let altkey = InodeAltKey::from_stat(&st);
let mut found = None;
'search: loop {
match self.inode_map.get_alt(&altkey) {
// No existing entry found
None => break 'search,
Some(data) => {
let curr = data.refcount.load(Ordering::Acquire);
// forgot_one() has just destroyed the entry, retry...
if curr == 0 {
continue 'search;
}
// Saturating add to avoid integer overflow, it's not realistic to saturate u64.
let new = curr.saturating_add(1);
// Synchronizes with the forgot_one()
if data
.refcount
.compare_exchange(curr, new, Ordering::AcqRel, Ordering::Acquire)
.is_ok()
{
found = Some(data.inode);
break;
}
}
}
}
let inode = if let Some(v) = found {
v
} else {
let mut inodes = self.inode_map.get_map_mut();
// Lookup inode_map again after acquiring the inode_map lock, as there might be another
// racing thread already added an inode with the same altkey while we're not holding
// the lock. If so just use the newly added inode, otherwise the inode will be replaced
// and results in EBADF.
match inodes.get_alt(&altkey).map(Arc::clone) {
Some(data) => {
trace!(
"fuse: do_lookup sees existing inode {} altkey {:?}",
data.inode,
altkey
);
data.refcount.fetch_add(1, Ordering::Relaxed);
data.inode
}
None => {
let inode = self.next_inode.fetch_add(1, Ordering::Relaxed);
if inode > VFS_MAX_INO {
return Err(io::Error::new(
io::ErrorKind::Other,
format!("max inode number reached: {}", VFS_MAX_INO),
));
}
trace!(
"fuse: do_lookup adds new inode {} altkey {:?}",
inode,
altkey
);
inodes.insert(inode, altkey, Arc::new(InodeData::new(inode, f, 1)));
inode
}
}
};
Ok(Entry {
inode,
generation: 0,
attr: st,
attr_timeout: self.cfg.attr_timeout,
entry_timeout: self.cfg.entry_timeout,
})
}
fn forget_one(
inodes: &mut MultikeyBTreeMap<Inode, InodeAltKey, Arc<InodeData>>,
inode: Inode,
count: u64,
) {
// ROOT_ID should not be forgotten, or we're not able to access to files any more.
if inode == fuse::ROOT_ID {
return;
}
if let Some(data) = inodes.get(&inode) {
// Acquiring the write lock on the inode map prevents new lookups from incrementing the
// refcount but there is the possibility that a previous lookup already acquired a
// reference to the inode data and is in the process of updating the refcount so we need
// to loop here until we can decrement successfully.
loop {
let curr = data.refcount.load(Ordering::Acquire);
// Saturating sub because it doesn't make sense for a refcount to go below zero and
// we don't want misbehaving clients to cause integer overflow.
let new = curr.saturating_sub(count);
trace!(
"fuse: forget inode {} refcount {}, count {}, new_count {}",
inode,
curr,
count,
new
);
// Synchronizes with the acquire load in `do_lookup`.
if data
.refcount
.compare_exchange(curr, new, Ordering::AcqRel, Ordering::Acquire)
.is_ok()
{
if new == 0 {
// We just removed the last refcount for this inode.
inodes.remove(&inode);
}
break;
}
}
}
}
fn do_r | elease(&se | identifier_name |
|
mod.rs | keyBTreeMap<Inode, InodeAltKey, Arc<InodeData>>> {
self.inodes.write().unwrap()
}
fn insert(&self, inode: Inode, altkey: InodeAltKey, data: InodeData) {
self.inodes
.write()
.unwrap()
.insert(inode, altkey, Arc::new(data));
}
}
struct HandleData {
inode: Inode,
file: File,
lock: Mutex<()>,
}
impl HandleData {
fn new(inode: Inode, file: File) -> Self {
HandleData {
inode,
file,
lock: Mutex::new(()),
}
}
fn get_file_mut(&self) -> (MutexGuard<()>, &File) {
(self.lock.lock().unwrap(), &self.file)
}
// When making use of the underlying RawFd, the caller must ensure that the Arc<HandleData>
// object is within scope. Otherwise it may cause race window to access wrong target fd.
// By introducing this method, we could explicitly audit all callers making use of the
// underlying RawFd.
fn get_handle_raw_fd(&self) -> RawFd {
self.file.as_raw_fd()
}
}
struct HandleMap {
handles: RwLock<BTreeMap<Handle, Arc<HandleData>>>,
}
impl HandleMap {
fn new() -> Self {
HandleMap {
handles: RwLock::new(BTreeMap::new()),
}
}
fn clear(&self) {
self.handles.write().unwrap().clear();
}
fn insert(&self, handle: Handle, data: HandleData) {
self.handles.write().unwrap().insert(handle, Arc::new(data));
}
fn release(&self, handle: Handle, inode: Inode) -> io::Result<()> {
let mut handles = self.handles.write().unwrap();
if let btree_map::Entry::Occupied(e) = handles.entry(handle) {
if e.get().inode == inode {
// We don't need to close the file here because that will happen automatically when
// the last `Arc` is dropped.
e.remove();
return Ok(());
}
}
Err(ebadf())
}
fn get(&self, handle: Handle, inode: Inode) -> io::Result<Arc<HandleData>> {
self.handles
.read()
.unwrap()
.get(&handle)
.filter(|hd| hd.inode == inode)
.map(Arc::clone)
.ok_or_else(ebadf)
}
}
#[repr(C, packed)]
#[derive(Clone, Copy, Debug, Default)]
struct LinuxDirent64 {
d_ino: libc::ino64_t,
d_off: libc::off64_t,
d_reclen: libc::c_ushort,
d_ty: libc::c_uchar,
}
unsafe impl ByteValued for LinuxDirent64 {}
/// The caching policy that the file system should report to the FUSE client. By default the FUSE
/// protocol uses close-to-open consistency. This means that any cached contents of the file are
/// invalidated the next time that file is opened.
#[derive(Debug, Clone, PartialEq)]
pub enum CachePolicy {
/// The client should never cache file data and all I/O should be directly forwarded to the
/// server. This policy must be selected when file contents may change without the knowledge of
/// the FUSE client (i.e., the file system does not have exclusive access to the directory).
Never,
/// The client is free to choose when and how to cache file data. This is the default policy and
/// uses close-to-open consistency as described in the enum documentation.
Auto,
/// The client should always cache file data. This means that the FUSE client will not
/// invalidate any cached data that was returned by the file system the last time the file was
/// opened. This policy should only be selected when the file system has exclusive access to the
/// directory.
Always,
}
impl FromStr for CachePolicy {
type Err = &'static str;
fn from_str(s: &str) -> Result<Self, Self::Err> {
| impl Default for CachePolicy {
fn default() -> Self {
CachePolicy::Auto
}
}
/// Options that configure the behavior of the passthrough fuse file system.
#[derive(Debug, Clone, PartialEq)]
pub struct Config {
/// How long the FUSE client should consider directory entries to be valid. If the contents of a
/// directory can only be modified by the FUSE client (i.e., the file system has exclusive
/// access), then this should be a large value.
///
/// The default value for this option is 5 seconds.
pub entry_timeout: Duration,
/// How long the FUSE client should consider file and directory attributes to be valid. If the
/// attributes of a file or directory can only be modified by the FUSE client (i.e., the file
/// system has exclusive access), then this should be set to a large value.
///
/// The default value for this option is 5 seconds.
pub attr_timeout: Duration,
/// The caching policy the file system should use. See the documentation of `CachePolicy` for
/// more details.
pub cache_policy: CachePolicy,
/// Whether the file system should enabled writeback caching. This can improve performance as it
/// allows the FUSE client to cache and coalesce multiple writes before sending them to the file
/// system. However, enabling this option can increase the risk of data corruption if the file
/// contents can change without the knowledge of the FUSE client (i.e., the server does **NOT**
/// have exclusive access). Additionally, the file system should have read access to all files
/// in the directory it is serving as the FUSE client may send read requests even for files
/// opened with `O_WRONLY`.
///
/// Therefore callers should only enable this option when they can guarantee that: 1) the file
/// system has exclusive access to the directory and 2) the file system has read permissions for
/// all files in that directory.
///
/// The default value for this option is `false`.
pub writeback: bool,
/// The path of the root directory.
///
/// The default is `/`.
pub root_dir: String,
/// Whether the file system should support Extended Attributes (xattr). Enabling this feature may
/// have a significant impact on performance, especially on write parallelism. This is the result
/// of FUSE attempting to remove the special file privileges after each write request.
///
/// The default value for this options is `false`.
pub xattr: bool,
/// To be compatible with Vfs and PseudoFs, PassthroughFs needs to prepare
/// root inode before accepting INIT request.
///
/// The default value for this option is `true`.
pub do_import: bool,
/// Control whether no_open is allowed.
///
/// The default value for this option is `false`.
pub no_open: bool,
/// Control whether no_opendir is allowed.
///
/// The default value for this option is `false`.
pub no_opendir: bool,
}
impl Default for Config {
fn default() -> Self {
Config {
entry_timeout: Duration::from_secs(5),
attr_timeout: Duration::from_secs(5),
cache_policy: Default::default(),
writeback: false,
root_dir: String::from("/"),
xattr: false,
do_import: true,
no_open: false,
no_opendir: false,
}
}
}
/// A file system that simply "passes through" all requests it receives to the underlying file
/// system.
///
/// To keep the implementation simple it servers the contents of its root directory. Users
/// that wish to serve only a specific directory should set up the environment so that that
/// directory ends up as the root of the file system process. One way to accomplish this is via a
/// combination of mount namespaces and the pivot_root system call.
pub struct PassthroughFs<D> {
// File descriptors for various points in the file system tree. These fds are always opened with
// the `O_PATH` option so they cannot be used for reading or writing any data. See the
// documentation of the `O_PATH` flag in `open(2)` for more details on what one can and cannot
// do with an fd opened with this flag.
inode_map: InodeMap,
next_inode: AtomicU64,
// File descriptors for open files and directories. Unlike the fds in `inodes`, these _can_ be
// used for reading and writing data.
handle_map: HandleMap,
next_handle: AtomicU64,
// File descriptor pointing to the `/proc` directory. This is used to convert an fd from
// `inodes` into one that can go into `handles`. This is accomplished by reading | match s {
"never" | "Never" | "NEVER" | "none" | "None" | "NONE" => Ok(CachePolicy::Never),
"auto" | "Auto" | "AUTO" => Ok(CachePolicy::Auto),
"always" | "Always" | "ALWAYS" => Ok(CachePolicy::Always),
_ => Err("invalid cache policy"),
}
}
}
| identifier_body |
CollectGame.js | cookie('collect_high_score') != '') {
this.high_score = $.cookie('collect_high_score');
}
},
create: function() {
console.log('Collect game');
this.background_music = this.game.add.audio('boss_background_music');
this.right_answer_sound = this.game.add.audio('right_answer_sound');
this.wrong_answer_sound = this.game.add.audio('wrong_answer_sound');
this.win_sound = this.game.add.audio('win_sound');
// Manage Layers
this.background_layer = this.game.add.group();
this.background_layer.z = 0;
// move button group
this.move_button_group = this.game.add.group();
this.move_button_group.z = 1;
this.up_button = this.game.add.sprite(50, 175, 'arrowUp');
this.up_button.inputEnabled = true;
this.down_button = this.game.add.sprite(50, 425, 'arrowDown');
this.down_button.inputEnabled = true;
this.game.input.onDown.add(this.activeInput, this);
this.game.input.onUp.add(this.releaseInput, this);
// Pause button / ui group
this.ui_layer = this.game.add.group();
this.ui_layer.z = 2;
// Create rock group
this.boulders = this.game.add.group();
// Score display
this.score_text = this.game.add.text(this.game.width - 145, 9, this.score + '', this.text_style);
this.score_text.anchor.setTo(1, 0);
//this.score_text.fixedToCamera = true;
this.ui_layer.add(this.score_text);
// Create zcar
this.zcar = this.game.add.sprite(337, 443, 'zcar');
this.zcar.anchor.setTo(.5, 1);
// Instructions
this.instructions = this.game.add.sprite(0, 0, 'collect_instructions');
this.start_button = this.game.add.button(this.game.world.centerX, this.game.world.height - 90, 'yellow_buttons', this.killInstructions, this, 3, 3, 4);
this.start_button.alpha = 0;
this.start_button.anchor.setTo(0.5, 0.5);
this.start_text = this.game.add.text(4, 0, 'START', {font: '30pt kenvector_future', fill: '#000', align: 'center'});
this.start_text.anchor.setTo(0.5, 0.5);
this.start_button.addChild(this.start_text);
// Initialize scoreboard
this.scoreboard = this.game.add.group();
var instruction_audio = this.game.add.audio('collect_instruction_sound');
instruction_audio.onStop.add(function(){
this.game.add.tween(this.start_button).to({alpha: 1}, 500, null, true);
}, this);
instruction_audio.play();
},
activeInput: function() {
this.inputActive = true;
},
releaseInput: function() {
this.inputActive = false;
},
killInstructions: function() {
this.start_button.destroy();
this.instructions.destroy();
this.startLevel();
},
update: function() {
if (!this.started) {
return;
}
if (this.inputActive) {
if (this.up_button.input.pointerOver()) {
//this.zcar.body.velocity.y = 200;
this.zcar.y -= 5;
if (this.zcar.y <= 200) {
this.zcar.y = 200;
}
}
if (this.down_button.input.pointerOver()) {
//this.zcar.body.velocity.y = 200;
this.zcar.y += 5;
if (this.zcar.y >= 650) {
this.zcar.y = 650;
}
}
}
this.gametime = this.gametime+1;
if (this.gametime >= 150) {
this.gametime = this.gametime-150;
this.generateBoulder();
}
this.game.physics.overlap(this.zcar, this.boulders, this.touchBoulder, null, this);
if (this.numCollected == 3) {
this.winLevel();
}
},
generateBoulder: function() {
boulderPos = this.game.rnd.integerInRange(1, 6)
while (boulderPos == this.lastBoulderPosition) {
boulderPos = this.game.rnd.integerInRange(1, 6)
}
this.lastBoulderPosition = boulderPos;
boulder = this.boulders.create(1220, 100*boulderPos, 'boulder');
boulder.body.gravity.x = -80;
boulder.anchor.setTo(0,0);
// 1 in 4 change of generating the right answer
boulderrnd = this.game.rnd.integerInRange(1, 4);
console.log('boulderrnd' + boulderrnd);
if (boulderrnd == 2) {
boulderVal = this.answer;
}
else {
boulderVal = this.game.rnd.integerInRange(1, 20);
}
while (boulderVal == this.lastBoulderValue) {
boulderVal = this.game.rnd.integerInRange(1, 20);
}
this.lastBoulderValue = boulderVal;
boulder_text = this.game.add.text(15, 15, boulderVal, {font: '40px kenvector_future', fill: '#fff', align: 'center'});
boulder.value = boulderVal;
boulder_text.anchor.setTo(0, 0);
boulder.addChild(boulder_text);
/*theB = this.boulders.create(1000, 800, 'boulder');
rock = this.rocks.create(this.game.rnd.integerInRange(1, 4)*280 +82, 1, 'rock');
theB.body.gravity.x = -40;
theB.anchor.setTo(0,0);*/
//boulder.value = this.boulderVal;
//console.log('VALUE: ' + boulder.value);
//console.log('boulder');
//boulder_text = this.game.add.text(15, 15, boulder.value, {font: '40px kenvector_future', fill: '#fff', align: 'center'});
},
/*reset: function() {
this.zcar.x = 337;
this.started = false;
this.boulders.destroy();
this.boulders = this.game.add.group();
},*/
startLevel: function() {
this.scoreboard.destroy();
/*if (this.game.global_vars.load_saved_state) {
this.current_level = this.game.global_vars.saved_level;
this.game.global_vars.load_saved_state = false;
}*/
// Load level specific things
this.background = this.game.add.sprite(0, 0, this.level_images[this.current_level]['background']);
this.background_layer.add(this.background);
this.difficulty_text = this.game.add.text(80, 10, 'Difficulty ' + this.game.global_vars.diff_score, {font: '20px kenvector_future', fill: '#fff'});
//this.started = false;
//this.boulders = this.game.add.group();
//this.startRace();
this.started = true;
this.displayNewProblem();
// commented out to test 10/17
//this.background_music.play(0,0,1,true);
},
startRace: function() {
this.started = true;
this.displayNewProblem();
// commented out to test 10/17
//this.background_music.play(0,0,1,true);
},
displayNewProblem: function() {
var problem = this.game.getMathProblem('addSolution', 'easy');
this.answer = problem.answer;
if (this.problem_text == null || !this.problem_text.exists) {
this.problem_text = this.game.add.text(640, 100, problem.text, {font: '40px kenvector_future', fill: '#fff'});
this.problem_text.anchor.setTo(0.5, 0.5);
} else {
this.problem_text.setText(problem.text);
}
},
moveUp: function() {
this.zcar.body.velocity.y = 200;
},
moveDown: function() {
this.zcar.body.velocity.y = -200;
},
checkAnswer: function(answer) {
console.log('checking: ' + answer + " and " + this.answer);
if (this.answer != answer){
this.wrong_answer_sound.play();
this.game.global_vars.diff_score -= 1;
if (this.game.global_vars.diff_score < 0) {
this.game.global_vars.diff_score = 0;
}
this.displayNewProblem();
this.score -= 30;
if (this.score < 0) |
}
if (this.answer == answer) {
| {
this.score = 0;
} | conditional_block |
CollectGame.js | $.cookie('collect_high_score') != '') {
this.high_score = $.cookie('collect_high_score');
}
},
create: function() {
console.log('Collect game');
this.background_music = this.game.add.audio('boss_background_music');
this.right_answer_sound = this.game.add.audio('right_answer_sound');
this.wrong_answer_sound = this.game.add.audio('wrong_answer_sound');
this.win_sound = this.game.add.audio('win_sound');
// Manage Layers
this.background_layer = this.game.add.group();
this.background_layer.z = 0;
// move button group
this.move_button_group = this.game.add.group();
this.move_button_group.z = 1;
this.up_button = this.game.add.sprite(50, 175, 'arrowUp');
this.up_button.inputEnabled = true;
this.down_button = this.game.add.sprite(50, 425, 'arrowDown');
this.down_button.inputEnabled = true;
this.game.input.onDown.add(this.activeInput, this);
this.game.input.onUp.add(this.releaseInput, this);
// Pause button / ui group
this.ui_layer = this.game.add.group();
this.ui_layer.z = 2;
// Create rock group
this.boulders = this.game.add.group();
// Score display
this.score_text = this.game.add.text(this.game.width - 145, 9, this.score + '', this.text_style);
this.score_text.anchor.setTo(1, 0);
//this.score_text.fixedToCamera = true;
this.ui_layer.add(this.score_text);
// Create zcar
this.zcar = this.game.add.sprite(337, 443, 'zcar');
this.zcar.anchor.setTo(.5, 1);
// Instructions
this.instructions = this.game.add.sprite(0, 0, 'collect_instructions');
this.start_button = this.game.add.button(this.game.world.centerX, this.game.world.height - 90, 'yellow_buttons', this.killInstructions, this, 3, 3, 4);
this.start_button.alpha = 0;
this.start_button.anchor.setTo(0.5, 0.5);
this.start_text = this.game.add.text(4, 0, 'START', {font: '30pt kenvector_future', fill: '#000', align: 'center'});
this.start_text.anchor.setTo(0.5, 0.5);
this.start_button.addChild(this.start_text);
// Initialize scoreboard
this.scoreboard = this.game.add.group();
var instruction_audio = this.game.add.audio('collect_instruction_sound');
instruction_audio.onStop.add(function(){
this.game.add.tween(this.start_button).to({alpha: 1}, 500, null, true);
}, this);
instruction_audio.play();
},
activeInput: function() {
this.inputActive = true;
},
releaseInput: function() {
this.inputActive = false;
},
killInstructions: function() {
this.start_button.destroy();
this.instructions.destroy();
this.startLevel();
},
update: function() {
if (!this.started) {
return;
}
if (this.inputActive) {
if (this.up_button.input.pointerOver()) {
//this.zcar.body.velocity.y = 200;
this.zcar.y -= 5;
if (this.zcar.y <= 200) {
this.zcar.y = 200;
}
}
if (this.down_button.input.pointerOver()) {
//this.zcar.body.velocity.y = 200;
this.zcar.y += 5;
if (this.zcar.y >= 650) {
this.zcar.y = 650;
}
}
}
this.gametime = this.gametime+1;
if (this.gametime >= 150) {
this.gametime = this.gametime-150;
this.generateBoulder();
}
this.game.physics.overlap(this.zcar, this.boulders, this.touchBoulder, null, this);
if (this.numCollected == 3) {
this.winLevel();
}
},
generateBoulder: function() {
boulderPos = this.game.rnd.integerInRange(1, 6)
while (boulderPos == this.lastBoulderPosition) {
boulderPos = this.game.rnd.integerInRange(1, 6)
}
this.lastBoulderPosition = boulderPos;
boulder = this.boulders.create(1220, 100*boulderPos, 'boulder');
boulder.body.gravity.x = -80;
boulder.anchor.setTo(0,0);
// 1 in 4 change of generating the right answer
boulderrnd = this.game.rnd.integerInRange(1, 4);
console.log('boulderrnd' + boulderrnd);
if (boulderrnd == 2) {
boulderVal = this.answer;
}
else {
boulderVal = this.game.rnd.integerInRange(1, 20);
}
while (boulderVal == this.lastBoulderValue) {
boulderVal = this.game.rnd.integerInRange(1, 20);
}
this.lastBoulderValue = boulderVal;
boulder_text = this.game.add.text(15, 15, boulderVal, {font: '40px kenvector_future', fill: '#fff', align: 'center'});
boulder.value = boulderVal;
boulder_text.anchor.setTo(0, 0);
boulder.addChild(boulder_text);
/*theB = this.boulders.create(1000, 800, 'boulder');
rock = this.rocks.create(this.game.rnd.integerInRange(1, 4)*280 +82, 1, 'rock');
theB.body.gravity.x = -40;
theB.anchor.setTo(0,0);*/ | //boulder.value = this.boulderVal;
//console.log('VALUE: ' + boulder.value);
//console.log('boulder');
//boulder_text = this.game.add.text(15, 15, boulder.value, {font: '40px kenvector_future', fill: '#fff', align: 'center'});
},
/*reset: function() {
this.zcar.x = 337;
this.started = false;
this.boulders.destroy();
this.boulders = this.game.add.group();
},*/
startLevel: function() {
this.scoreboard.destroy();
/*if (this.game.global_vars.load_saved_state) {
this.current_level = this.game.global_vars.saved_level;
this.game.global_vars.load_saved_state = false;
}*/
// Load level specific things
this.background = this.game.add.sprite(0, 0, this.level_images[this.current_level]['background']);
this.background_layer.add(this.background);
this.difficulty_text = this.game.add.text(80, 10, 'Difficulty ' + this.game.global_vars.diff_score, {font: '20px kenvector_future', fill: '#fff'});
//this.started = false;
//this.boulders = this.game.add.group();
//this.startRace();
this.started = true;
this.displayNewProblem();
// commented out to test 10/17
//this.background_music.play(0,0,1,true);
},
startRace: function() {
this.started = true;
this.displayNewProblem();
// commented out to test 10/17
//this.background_music.play(0,0,1,true);
},
displayNewProblem: function() {
var problem = this.game.getMathProblem('addSolution', 'easy');
this.answer = problem.answer;
if (this.problem_text == null || !this.problem_text.exists) {
this.problem_text = this.game.add.text(640, 100, problem.text, {font: '40px kenvector_future', fill: '#fff'});
this.problem_text.anchor.setTo(0.5, 0.5);
} else {
this.problem_text.setText(problem.text);
}
},
moveUp: function() {
this.zcar.body.velocity.y = 200;
},
moveDown: function() {
this.zcar.body.velocity.y = -200;
},
checkAnswer: function(answer) {
console.log('checking: ' + answer + " and " + this.answer);
if (this.answer != answer){
this.wrong_answer_sound.play();
this.game.global_vars.diff_score -= 1;
if (this.game.global_vars.diff_score < 0) {
this.game.global_vars.diff_score = 0;
}
this.displayNewProblem();
this.score -= 30;
if (this.score < 0) {
this.score = 0;
}
}
if (this.answer == answer) {
| random_line_split |
|
app.js | = {
x: 0,
y: 0
};
var imageX = 50;
var imageY = 50;
var tableGlobal;
// var numXscale = canvas.clientWidth / canvas.width;
// var numYscale = canvas.clientHeight / canvas.height;
var imageWidth, imageHeight, imageRight, imageBottom;
var draggingImage = false;
var startX;
var startY;
// var img = new Image();
// img.onload = function () {
// imageWidth = img.width;
// imageHeight = img.height;
// imageRight = imageX + imageWidth;
// imageBottom = imageY + imageHeight;
// draw(true, false);
// };
// img.src = "https://dl.dropboxusercontent.com/u/139992952/stackoverflow/facesSmall.png";
var imagDrop = document.createElement("img");
imagDrop.addEventListener("load", function() {
//clearCanvas();
imageWidth = imagDrop.width;
imageHeight = imagDrop.height;
imageRight = imageX + imageWidth;
imageBottom = imageY + imageHeight;
draw(true, false);
console.log("test");
//ctx.drawImage(imagDrop, 0, 0);
}, false);
// To enable drag and drop
canvas.addEventListener("dragover", function(evt) {
evt.preventDefault();
}, false);
// Handle dropped image file - only Firefox and Google Chrome
canvas.addEventListener("drop", function(evt) {
var files = evt.dataTransfer.files;
if (files.length > 0) {
var file = files[0];
if (typeof FileReader !== "undefined" && file.type.indexOf("image") != -1) {
var reader = new FileReader();
// Note: addEventListener doesn't work in Google Chrome for this event
reader.onload = function(evt) {
imagDrop.src = evt.target.result;
};
reader.readAsDataURL(file);
}
}
evt.preventDefault();
}, false);
updateAxis();
addTable();
function togglePin() {
if (flagPin) {
document.getElementById('idButtonPin').innerHTML = 'Start pinning';
flagPin = false;
} else {
document.getElementById('idButtonPin').innerHTML = 'Stop pinning';
flagPin = true;
}
}
function addTable() {
var newTable = document.createElement('table');
newTable.setAttribute("style", "float:left;position:relative");
var header = newTable.createTHead();
var row = header.insertRow(0);
var cell = row.insertCell(0);
cell.innerHTML = "X";
var cell = row.insertCell(1);
cell.innerHTML = "Y";
document.getElementById('tables').appendChild(newTable);
tableGlobal = newTable;
}
function canvas2realX(numX) {
return numX*canvas.clientWidth / canvas.width;
}
function canvas2realY(numY) {
return numY*canvas.clientHeight / canvas.height;
}
function drawAxis() {
ctx.lineWidth = 3;
ctx.strokeStyle = '#333';
ctx.font = 'italic 8pt sans-serif';
ctx.textAlign = "center";
// Draw the axises
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(xPadding, 0);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(canvas.width, canvas.height - yPadding);
ctx.stroke();
// // Draw the X value texts
ctx.lineWidth = 1;
for (var i = 0; i <= numMaxX - numMinX; i += numStepX) {
ctx.fillText(i, getXPixel(i), canvas.height - yPadding + 20);
ctx.beginPath();
ctx.moveTo(getXPixel(i), canvas.height - yPadding);
ctx.lineTo(getXPixel(i), 0);
ctx.stroke();
}
ctx.textAlign = "right";
ctx.textBaseline = "middle";
for (var i = 0; i <= numMaxY - numMinY; i += numStepY) {
ctx.fillText(i, xPadding - 10, getYPixel(i));
ctx.beginPath();
ctx.moveTo(xPadding, getYPixel(i));
ctx.lineTo(canvas.width, getYPixel(i));
ctx.stroke();
}
ctx.strokeStyle = '#f00';
}
function updateAxis() {
numMaxX = parseInt(document.getElementById('MaxX').value);
numMaxY = parseInt(document.getElementById('MaxY').value);
numStepX = parseInt(document.getElementById('StepX').value);
numStepY = parseInt(document.getElementById('StepY').value);
ctx.clearRect(0, 0, canvas.width, canvas.height);
drawAxis();
}
function getXPixel(val) {
return ((canvas.width - 2 * xPadding) / numMaxX) * val + (xPadding);
}
// Return the y pixel for a graph point
function getYPixel(val) {
return canvas.height - (((canvas.height - 2 * yPadding) / numMaxY) * val) - yPadding;
}
function draw(withAnchors, withBorders) {
// clear the canvas
ctx.clearRect(0, 0, canvas.width, canvas.height);
updateAxis();
// draw the image
ctx.globalAlpha = 0.4;
ctx.drawImage(imagDrop, 0, 0, imagDrop.width, imagDrop.height, imageX, imageY, imageWidth, imageHeight);
// optionally draw the draggable anchors
if (withAnchors) {
drawDragAnchor(imageX, imageY);
drawDragAnchor(imageRight, imageY);
drawDragAnchor(imageRight, imageBottom);
drawDragAnchor(imageX, imageBottom);
}
// optionally draw the connecting anchor lines
if (withBorders) {
ctx.beginPath();
ctx.moveTo(imageX, imageY);
ctx.lineTo(imageRight, imageY);
ctx.lineTo(imageRight, imageBottom);
ctx.lineTo(imageX, imageBottom);
ctx.closePath();
ctx.stroke();
}
}
function drawDragAnchor(x, y) {
ctx.beginPath();
ctx.arc(x, y, resizerRadius, 0, pi2, false);
ctx.closePath();
ctx.fill();
}
function anchorHitTest(x, y) {
var dx, dy;
// top-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageY);
if (dx * dx + dy * dy <= rr) {
return (0);
}
// top-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageY);
console.log(dx.toString()+' '+dy.toString());
if (dx * dx + dy * dy <= rr) {
return (1);
}
// bottom-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) {
return (2);
}
// bottom-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) {
return (3);
}
return (-1);
}
function hitImage(x, y) {
return (x > canvas2realX(imageX) && x < canvas2realX(imageX + imageWidth) && y > canvas2realY(imageY) && y < canvas2realY(imageY + imageHeight));
}
function handleMouseDown(e) {
if (!flagPin) {
startX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft);
startY = parseInt(e.clientY - document.getElementById('canvas').offsetTop);
console.log(startX.toString()+'_'+startY.toString());
draggingResizer = anchorHitTest(startX, startY);
draggingImage = draggingResizer < 0 && hitImage(startX, startY);
} else {
var row = tableGlobal.insertRow(tableGlobal.rows.length);
var cell1 = row.insertCell(0);
var cell2 = row.insertCell(1);
cell2.innerHTML = Math.round((canvas.clientHeight - parseInt(e.clientY - document.getElementById('canvas').offsetTop) - canvas2realY(yPadding)) / ((canvas.clientHeight - 2 * canvas2realY(yPadding)) / numMaxY));
cell1.innerHTML = Math.round((parseInt(e.clientX - document.getElementById('canvas').offsetLeft) - canvas2realX(xPadding)) / ((canvas.clientWidth - 2 * canvas2realX(xPadding)) / numMaxX));
}
}
function handleMouseUp(e) |
function handleMouseOut(e) {
if (!flagPin) {
handleMouseUp(e);
}
}
function handleMouseMove(e) {
if (!flagPin) {
if (draggingResizer > -1) {
mouseX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft)*canvas.width/canvas.clientWidth;
mouseY = parseInt(e.clientY - document.getElementById('canvas').offsetTop)*canvas.height/canvas.clientHeight;
console.log(mouseX.toString()+','+mouseY.toString());
// resize the image
switch (draggingResizer) {
case 0:
//top-left
imageX = mouseX;
imageWidth = imageRight - mouseX;
imageY = mouseY;
imageHeight = | {
if (!flagPin) {
draggingResizer = -1;
draggingImage = false;
draw(true, false);
}
} | identifier_body |
app.js | = {
x: 0,
y: 0
};
var imageX = 50;
var imageY = 50;
var tableGlobal;
// var numXscale = canvas.clientWidth / canvas.width;
// var numYscale = canvas.clientHeight / canvas.height;
var imageWidth, imageHeight, imageRight, imageBottom;
var draggingImage = false;
var startX;
var startY;
// var img = new Image();
// img.onload = function () {
// imageWidth = img.width;
// imageHeight = img.height;
// imageRight = imageX + imageWidth;
// imageBottom = imageY + imageHeight;
// draw(true, false);
// };
// img.src = "https://dl.dropboxusercontent.com/u/139992952/stackoverflow/facesSmall.png";
var imagDrop = document.createElement("img");
imagDrop.addEventListener("load", function() {
//clearCanvas();
imageWidth = imagDrop.width;
imageHeight = imagDrop.height;
imageRight = imageX + imageWidth;
imageBottom = imageY + imageHeight;
draw(true, false);
console.log("test");
//ctx.drawImage(imagDrop, 0, 0);
}, false);
// To enable drag and drop
canvas.addEventListener("dragover", function(evt) {
evt.preventDefault();
}, false);
// Handle dropped image file - only Firefox and Google Chrome
canvas.addEventListener("drop", function(evt) {
var files = evt.dataTransfer.files;
if (files.length > 0) {
var file = files[0];
if (typeof FileReader !== "undefined" && file.type.indexOf("image") != -1) {
var reader = new FileReader();
// Note: addEventListener doesn't work in Google Chrome for this event
reader.onload = function(evt) {
imagDrop.src = evt.target.result;
};
reader.readAsDataURL(file);
}
}
evt.preventDefault();
}, false);
updateAxis();
addTable();
function togglePin() {
if (flagPin) {
document.getElementById('idButtonPin').innerHTML = 'Start pinning';
flagPin = false;
} else {
document.getElementById('idButtonPin').innerHTML = 'Stop pinning';
flagPin = true;
}
}
function addTable() {
var newTable = document.createElement('table');
newTable.setAttribute("style", "float:left;position:relative");
var header = newTable.createTHead();
var row = header.insertRow(0);
var cell = row.insertCell(0);
cell.innerHTML = "X";
var cell = row.insertCell(1);
cell.innerHTML = "Y";
document.getElementById('tables').appendChild(newTable);
tableGlobal = newTable;
}
function canvas2realX(numX) {
return numX*canvas.clientWidth / canvas.width;
}
function canvas2realY(numY) {
return numY*canvas.clientHeight / canvas.height;
}
function drawAxis() {
ctx.lineWidth = 3;
ctx.strokeStyle = '#333';
ctx.font = 'italic 8pt sans-serif';
ctx.textAlign = "center";
// Draw the axises
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(xPadding, 0);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(canvas.width, canvas.height - yPadding);
ctx.stroke();
// // Draw the X value texts
ctx.lineWidth = 1;
for (var i = 0; i <= numMaxX - numMinX; i += numStepX) {
ctx.fillText(i, getXPixel(i), canvas.height - yPadding + 20);
ctx.beginPath();
ctx.moveTo(getXPixel(i), canvas.height - yPadding);
ctx.lineTo(getXPixel(i), 0);
ctx.stroke();
}
ctx.textAlign = "right";
ctx.textBaseline = "middle";
for (var i = 0; i <= numMaxY - numMinY; i += numStepY) {
ctx.fillText(i, xPadding - 10, getYPixel(i));
ctx.beginPath();
ctx.moveTo(xPadding, getYPixel(i));
ctx.lineTo(canvas.width, getYPixel(i));
ctx.stroke();
}
ctx.strokeStyle = '#f00';
}
function updateAxis() {
numMaxX = parseInt(document.getElementById('MaxX').value);
numMaxY = parseInt(document.getElementById('MaxY').value);
numStepX = parseInt(document.getElementById('StepX').value);
numStepY = parseInt(document.getElementById('StepY').value);
ctx.clearRect(0, 0, canvas.width, canvas.height);
drawAxis();
}
function getXPixel(val) {
return ((canvas.width - 2 * xPadding) / numMaxX) * val + (xPadding);
}
// Return the y pixel for a graph point
function getYPixel(val) {
return canvas.height - (((canvas.height - 2 * yPadding) / numMaxY) * val) - yPadding;
}
function draw(withAnchors, withBorders) {
// clear the canvas
ctx.clearRect(0, 0, canvas.width, canvas.height);
updateAxis();
// draw the image
ctx.globalAlpha = 0.4;
ctx.drawImage(imagDrop, 0, 0, imagDrop.width, imagDrop.height, imageX, imageY, imageWidth, imageHeight);
// optionally draw the draggable anchors
if (withAnchors) {
drawDragAnchor(imageX, imageY);
drawDragAnchor(imageRight, imageY);
drawDragAnchor(imageRight, imageBottom);
drawDragAnchor(imageX, imageBottom);
}
// optionally draw the connecting anchor lines
if (withBorders) {
ctx.beginPath();
ctx.moveTo(imageX, imageY);
ctx.lineTo(imageRight, imageY);
ctx.lineTo(imageRight, imageBottom);
ctx.lineTo(imageX, imageBottom);
ctx.closePath();
ctx.stroke();
}
}
function drawDragAnchor(x, y) {
ctx.beginPath();
ctx.arc(x, y, resizerRadius, 0, pi2, false);
ctx.closePath();
ctx.fill();
}
function anchorHitTest(x, y) {
var dx, dy;
// top-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageY);
if (dx * dx + dy * dy <= rr) {
return (0);
}
// top-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageY);
console.log(dx.toString()+' '+dy.toString());
if (dx * dx + dy * dy <= rr) {
return (1);
}
// bottom-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) |
// bottom-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) {
return (3);
}
return (-1);
}
function hitImage(x, y) {
return (x > canvas2realX(imageX) && x < canvas2realX(imageX + imageWidth) && y > canvas2realY(imageY) && y < canvas2realY(imageY + imageHeight));
}
function handleMouseDown(e) {
if (!flagPin) {
startX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft);
startY = parseInt(e.clientY - document.getElementById('canvas').offsetTop);
console.log(startX.toString()+'_'+startY.toString());
draggingResizer = anchorHitTest(startX, startY);
draggingImage = draggingResizer < 0 && hitImage(startX, startY);
} else {
var row = tableGlobal.insertRow(tableGlobal.rows.length);
var cell1 = row.insertCell(0);
var cell2 = row.insertCell(1);
cell2.innerHTML = Math.round((canvas.clientHeight - parseInt(e.clientY - document.getElementById('canvas').offsetTop) - canvas2realY(yPadding)) / ((canvas.clientHeight - 2 * canvas2realY(yPadding)) / numMaxY));
cell1.innerHTML = Math.round((parseInt(e.clientX - document.getElementById('canvas').offsetLeft) - canvas2realX(xPadding)) / ((canvas.clientWidth - 2 * canvas2realX(xPadding)) / numMaxX));
}
}
function handleMouseUp(e) {
if (!flagPin) {
draggingResizer = -1;
draggingImage = false;
draw(true, false);
}
}
function handleMouseOut(e) {
if (!flagPin) {
handleMouseUp(e);
}
}
function handleMouseMove(e) {
if (!flagPin) {
if (draggingResizer > -1) {
mouseX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft)*canvas.width/canvas.clientWidth;
mouseY = parseInt(e.clientY - document.getElementById('canvas').offsetTop)*canvas.height/canvas.clientHeight;
console.log(mouseX.toString()+','+mouseY.toString());
// resize the image
switch (draggingResizer) {
case 0:
//top-left
imageX = mouseX;
imageWidth = imageRight - mouseX;
imageY = mouseY;
imageHeight = | {
return (2);
} | conditional_block |
app.js | izer = {
x: 0,
y: 0
};
var imageX = 50;
var imageY = 50;
var tableGlobal;
// var numXscale = canvas.clientWidth / canvas.width;
// var numYscale = canvas.clientHeight / canvas.height;
var imageWidth, imageHeight, imageRight, imageBottom;
var draggingImage = false;
var startX;
var startY;
// var img = new Image();
// img.onload = function () {
// imageWidth = img.width;
// imageHeight = img.height;
// imageRight = imageX + imageWidth;
// imageBottom = imageY + imageHeight;
// draw(true, false);
// };
// img.src = "https://dl.dropboxusercontent.com/u/139992952/stackoverflow/facesSmall.png";
var imagDrop = document.createElement("img");
imagDrop.addEventListener("load", function() {
//clearCanvas();
imageWidth = imagDrop.width;
imageHeight = imagDrop.height;
imageRight = imageX + imageWidth;
imageBottom = imageY + imageHeight;
draw(true, false);
console.log("test");
//ctx.drawImage(imagDrop, 0, 0);
}, false);
// To enable drag and drop
canvas.addEventListener("dragover", function(evt) {
evt.preventDefault();
}, false);
// Handle dropped image file - only Firefox and Google Chrome
canvas.addEventListener("drop", function(evt) {
var files = evt.dataTransfer.files;
if (files.length > 0) {
var file = files[0];
if (typeof FileReader !== "undefined" && file.type.indexOf("image") != -1) {
var reader = new FileReader();
// Note: addEventListener doesn't work in Google Chrome for this event
reader.onload = function(evt) {
imagDrop.src = evt.target.result; | };
reader.readAsDataURL(file);
}
}
evt.preventDefault();
}, false);
updateAxis();
addTable();
function togglePin() {
if (flagPin) {
document.getElementById('idButtonPin').innerHTML = 'Start pinning';
flagPin = false;
} else {
document.getElementById('idButtonPin').innerHTML = 'Stop pinning';
flagPin = true;
}
}
function addTable() {
var newTable = document.createElement('table');
newTable.setAttribute("style", "float:left;position:relative");
var header = newTable.createTHead();
var row = header.insertRow(0);
var cell = row.insertCell(0);
cell.innerHTML = "X";
var cell = row.insertCell(1);
cell.innerHTML = "Y";
document.getElementById('tables').appendChild(newTable);
tableGlobal = newTable;
}
function canvas2realX(numX) {
return numX*canvas.clientWidth / canvas.width;
}
function canvas2realY(numY) {
return numY*canvas.clientHeight / canvas.height;
}
function drawAxis() {
ctx.lineWidth = 3;
ctx.strokeStyle = '#333';
ctx.font = 'italic 8pt sans-serif';
ctx.textAlign = "center";
// Draw the axises
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(xPadding, 0);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(canvas.width, canvas.height - yPadding);
ctx.stroke();
// // Draw the X value texts
ctx.lineWidth = 1;
for (var i = 0; i <= numMaxX - numMinX; i += numStepX) {
ctx.fillText(i, getXPixel(i), canvas.height - yPadding + 20);
ctx.beginPath();
ctx.moveTo(getXPixel(i), canvas.height - yPadding);
ctx.lineTo(getXPixel(i), 0);
ctx.stroke();
}
ctx.textAlign = "right";
ctx.textBaseline = "middle";
for (var i = 0; i <= numMaxY - numMinY; i += numStepY) {
ctx.fillText(i, xPadding - 10, getYPixel(i));
ctx.beginPath();
ctx.moveTo(xPadding, getYPixel(i));
ctx.lineTo(canvas.width, getYPixel(i));
ctx.stroke();
}
ctx.strokeStyle = '#f00';
}
function updateAxis() {
numMaxX = parseInt(document.getElementById('MaxX').value);
numMaxY = parseInt(document.getElementById('MaxY').value);
numStepX = parseInt(document.getElementById('StepX').value);
numStepY = parseInt(document.getElementById('StepY').value);
ctx.clearRect(0, 0, canvas.width, canvas.height);
drawAxis();
}
function getXPixel(val) {
return ((canvas.width - 2 * xPadding) / numMaxX) * val + (xPadding);
}
// Return the y pixel for a graph point
function getYPixel(val) {
return canvas.height - (((canvas.height - 2 * yPadding) / numMaxY) * val) - yPadding;
}
function draw(withAnchors, withBorders) {
// clear the canvas
ctx.clearRect(0, 0, canvas.width, canvas.height);
updateAxis();
// draw the image
ctx.globalAlpha = 0.4;
ctx.drawImage(imagDrop, 0, 0, imagDrop.width, imagDrop.height, imageX, imageY, imageWidth, imageHeight);
// optionally draw the draggable anchors
if (withAnchors) {
drawDragAnchor(imageX, imageY);
drawDragAnchor(imageRight, imageY);
drawDragAnchor(imageRight, imageBottom);
drawDragAnchor(imageX, imageBottom);
}
// optionally draw the connecting anchor lines
if (withBorders) {
ctx.beginPath();
ctx.moveTo(imageX, imageY);
ctx.lineTo(imageRight, imageY);
ctx.lineTo(imageRight, imageBottom);
ctx.lineTo(imageX, imageBottom);
ctx.closePath();
ctx.stroke();
}
}
function drawDragAnchor(x, y) {
ctx.beginPath();
ctx.arc(x, y, resizerRadius, 0, pi2, false);
ctx.closePath();
ctx.fill();
}
function anchorHitTest(x, y) {
var dx, dy;
// top-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageY);
if (dx * dx + dy * dy <= rr) {
return (0);
}
// top-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageY);
console.log(dx.toString()+' '+dy.toString());
if (dx * dx + dy * dy <= rr) {
return (1);
}
// bottom-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) {
return (2);
}
// bottom-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) {
return (3);
}
return (-1);
}
function hitImage(x, y) {
return (x > canvas2realX(imageX) && x < canvas2realX(imageX + imageWidth) && y > canvas2realY(imageY) && y < canvas2realY(imageY + imageHeight));
}
function handleMouseDown(e) {
if (!flagPin) {
startX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft);
startY = parseInt(e.clientY - document.getElementById('canvas').offsetTop);
console.log(startX.toString()+'_'+startY.toString());
draggingResizer = anchorHitTest(startX, startY);
draggingImage = draggingResizer < 0 && hitImage(startX, startY);
} else {
var row = tableGlobal.insertRow(tableGlobal.rows.length);
var cell1 = row.insertCell(0);
var cell2 = row.insertCell(1);
cell2.innerHTML = Math.round((canvas.clientHeight - parseInt(e.clientY - document.getElementById('canvas').offsetTop) - canvas2realY(yPadding)) / ((canvas.clientHeight - 2 * canvas2realY(yPadding)) / numMaxY));
cell1.innerHTML = Math.round((parseInt(e.clientX - document.getElementById('canvas').offsetLeft) - canvas2realX(xPadding)) / ((canvas.clientWidth - 2 * canvas2realX(xPadding)) / numMaxX));
}
}
function handleMouseUp(e) {
if (!flagPin) {
draggingResizer = -1;
draggingImage = false;
draw(true, false);
}
}
function handleMouseOut(e) {
if (!flagPin) {
handleMouseUp(e);
}
}
function handleMouseMove(e) {
if (!flagPin) {
if (draggingResizer > -1) {
mouseX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft)*canvas.width/canvas.clientWidth;
mouseY = parseInt(e.clientY - document.getElementById('canvas').offsetTop)*canvas.height/canvas.clientHeight;
console.log(mouseX.toString()+','+mouseY.toString());
// resize the image
switch (draggingResizer) {
case 0:
//top-left
imageX = mouseX;
imageWidth = imageRight - mouseX;
imageY = mouseY;
imageHeight = image | random_line_split |
|
app.js | = {
x: 0,
y: 0
};
var imageX = 50;
var imageY = 50;
var tableGlobal;
// var numXscale = canvas.clientWidth / canvas.width;
// var numYscale = canvas.clientHeight / canvas.height;
var imageWidth, imageHeight, imageRight, imageBottom;
var draggingImage = false;
var startX;
var startY;
// var img = new Image();
// img.onload = function () {
// imageWidth = img.width;
// imageHeight = img.height;
// imageRight = imageX + imageWidth;
// imageBottom = imageY + imageHeight;
// draw(true, false);
// };
// img.src = "https://dl.dropboxusercontent.com/u/139992952/stackoverflow/facesSmall.png";
var imagDrop = document.createElement("img");
imagDrop.addEventListener("load", function() {
//clearCanvas();
imageWidth = imagDrop.width;
imageHeight = imagDrop.height;
imageRight = imageX + imageWidth;
imageBottom = imageY + imageHeight;
draw(true, false);
console.log("test");
//ctx.drawImage(imagDrop, 0, 0);
}, false);
// To enable drag and drop
canvas.addEventListener("dragover", function(evt) {
evt.preventDefault();
}, false);
// Handle dropped image file - only Firefox and Google Chrome
canvas.addEventListener("drop", function(evt) {
var files = evt.dataTransfer.files;
if (files.length > 0) {
var file = files[0];
if (typeof FileReader !== "undefined" && file.type.indexOf("image") != -1) {
var reader = new FileReader();
// Note: addEventListener doesn't work in Google Chrome for this event
reader.onload = function(evt) {
imagDrop.src = evt.target.result;
};
reader.readAsDataURL(file);
}
}
evt.preventDefault();
}, false);
updateAxis();
addTable();
function togglePin() {
if (flagPin) {
document.getElementById('idButtonPin').innerHTML = 'Start pinning';
flagPin = false;
} else {
document.getElementById('idButtonPin').innerHTML = 'Stop pinning';
flagPin = true;
}
}
function addTable() {
var newTable = document.createElement('table');
newTable.setAttribute("style", "float:left;position:relative");
var header = newTable.createTHead();
var row = header.insertRow(0);
var cell = row.insertCell(0);
cell.innerHTML = "X";
var cell = row.insertCell(1);
cell.innerHTML = "Y";
document.getElementById('tables').appendChild(newTable);
tableGlobal = newTable;
}
function canvas2realX(numX) {
return numX*canvas.clientWidth / canvas.width;
}
function canvas2realY(numY) {
return numY*canvas.clientHeight / canvas.height;
}
function drawAxis() {
ctx.lineWidth = 3;
ctx.strokeStyle = '#333';
ctx.font = 'italic 8pt sans-serif';
ctx.textAlign = "center";
// Draw the axises
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(xPadding, 0);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(xPadding, canvas.height - yPadding);
ctx.lineTo(canvas.width, canvas.height - yPadding);
ctx.stroke();
// // Draw the X value texts
ctx.lineWidth = 1;
for (var i = 0; i <= numMaxX - numMinX; i += numStepX) {
ctx.fillText(i, getXPixel(i), canvas.height - yPadding + 20);
ctx.beginPath();
ctx.moveTo(getXPixel(i), canvas.height - yPadding);
ctx.lineTo(getXPixel(i), 0);
ctx.stroke();
}
ctx.textAlign = "right";
ctx.textBaseline = "middle";
for (var i = 0; i <= numMaxY - numMinY; i += numStepY) {
ctx.fillText(i, xPadding - 10, getYPixel(i));
ctx.beginPath();
ctx.moveTo(xPadding, getYPixel(i));
ctx.lineTo(canvas.width, getYPixel(i));
ctx.stroke();
}
ctx.strokeStyle = '#f00';
}
function updateAxis() {
numMaxX = parseInt(document.getElementById('MaxX').value);
numMaxY = parseInt(document.getElementById('MaxY').value);
numStepX = parseInt(document.getElementById('StepX').value);
numStepY = parseInt(document.getElementById('StepY').value);
ctx.clearRect(0, 0, canvas.width, canvas.height);
drawAxis();
}
function getXPixel(val) {
return ((canvas.width - 2 * xPadding) / numMaxX) * val + (xPadding);
}
// Return the y pixel for a graph point
function getYPixel(val) {
return canvas.height - (((canvas.height - 2 * yPadding) / numMaxY) * val) - yPadding;
}
function | (withAnchors, withBorders) {
// clear the canvas
ctx.clearRect(0, 0, canvas.width, canvas.height);
updateAxis();
// draw the image
ctx.globalAlpha = 0.4;
ctx.drawImage(imagDrop, 0, 0, imagDrop.width, imagDrop.height, imageX, imageY, imageWidth, imageHeight);
// optionally draw the draggable anchors
if (withAnchors) {
drawDragAnchor(imageX, imageY);
drawDragAnchor(imageRight, imageY);
drawDragAnchor(imageRight, imageBottom);
drawDragAnchor(imageX, imageBottom);
}
// optionally draw the connecting anchor lines
if (withBorders) {
ctx.beginPath();
ctx.moveTo(imageX, imageY);
ctx.lineTo(imageRight, imageY);
ctx.lineTo(imageRight, imageBottom);
ctx.lineTo(imageX, imageBottom);
ctx.closePath();
ctx.stroke();
}
}
function drawDragAnchor(x, y) {
ctx.beginPath();
ctx.arc(x, y, resizerRadius, 0, pi2, false);
ctx.closePath();
ctx.fill();
}
function anchorHitTest(x, y) {
var dx, dy;
// top-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageY);
if (dx * dx + dy * dy <= rr) {
return (0);
}
// top-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageY);
console.log(dx.toString()+' '+dy.toString());
if (dx * dx + dy * dy <= rr) {
return (1);
}
// bottom-right
dx = x - canvas2realX(imageRight);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) {
return (2);
}
// bottom-left
dx = x - canvas2realX(imageX);
dy = y - canvas2realY(imageBottom);
if (dx * dx + dy * dy <= rr) {
return (3);
}
return (-1);
}
function hitImage(x, y) {
return (x > canvas2realX(imageX) && x < canvas2realX(imageX + imageWidth) && y > canvas2realY(imageY) && y < canvas2realY(imageY + imageHeight));
}
function handleMouseDown(e) {
if (!flagPin) {
startX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft);
startY = parseInt(e.clientY - document.getElementById('canvas').offsetTop);
console.log(startX.toString()+'_'+startY.toString());
draggingResizer = anchorHitTest(startX, startY);
draggingImage = draggingResizer < 0 && hitImage(startX, startY);
} else {
var row = tableGlobal.insertRow(tableGlobal.rows.length);
var cell1 = row.insertCell(0);
var cell2 = row.insertCell(1);
cell2.innerHTML = Math.round((canvas.clientHeight - parseInt(e.clientY - document.getElementById('canvas').offsetTop) - canvas2realY(yPadding)) / ((canvas.clientHeight - 2 * canvas2realY(yPadding)) / numMaxY));
cell1.innerHTML = Math.round((parseInt(e.clientX - document.getElementById('canvas').offsetLeft) - canvas2realX(xPadding)) / ((canvas.clientWidth - 2 * canvas2realX(xPadding)) / numMaxX));
}
}
function handleMouseUp(e) {
if (!flagPin) {
draggingResizer = -1;
draggingImage = false;
draw(true, false);
}
}
function handleMouseOut(e) {
if (!flagPin) {
handleMouseUp(e);
}
}
function handleMouseMove(e) {
if (!flagPin) {
if (draggingResizer > -1) {
mouseX = parseInt(e.clientX - document.getElementById('canvas').offsetLeft)*canvas.width/canvas.clientWidth;
mouseY = parseInt(e.clientY - document.getElementById('canvas').offsetTop)*canvas.height/canvas.clientHeight;
console.log(mouseX.toString()+','+mouseY.toString());
// resize the image
switch (draggingResizer) {
case 0:
//top-left
imageX = mouseX;
imageWidth = imageRight - mouseX;
imageY = mouseY;
imageHeight = image | draw | identifier_name |
Z_normal_8_2.py | 1.15]),
9: np.array([ -1.22, -0.76, -0.43, -0.14, 0.14, 0.43, 0.76, 1.22]),
10: np.array([ -1.28, -0.84, -0.52, -0.25, 0, 0.25, 0.52, 0.84, 1.28]),
11: np.array([ -1.34, -0.91, -0.6, -0.35, -0.11, 0.11, 0.35, 0.6, 0.91, 1.34]),
12: np.array([ -1.38, -0.97, -0.67, -0.43, -0.21, 0, 0.21, 0.43, 0.67, 0.97, 1.38]),
13: np.array([ -1.43, -1.02, -0.74, -0.5, -0.29, -0.1, 0.1, 0.29, 0.5, 0.74, 1.02, 1.43]),
14: np.array([ -1.47, -1.07, -0.79, -0.57, -0.37, -0.18, 0, 0.18, 0.37, 0.57, 0.79, 1.07, 1.47]),
15: np.array([ -1.5, -1.11, -0.84, -0.62, -0.43, -0.25, -0.08, 0.08, 0.25, 0.43, 0.62, 0.84, 1.11, 1.5]),
16: np.array([ -1.53, -1.15, -0.89, -0.67, -0.49, -0.32, -0.16, 0, 0.16, 0.32, 0.49, 0.67, 0.89, 1.15, 1.53]),
17: np.array([ -1.56, -1.19, -0.93, -0.72, -0.54, -0.38, -0.22, -0.07, 0.07, 0.22, 0.38, 0.54, 0.72, 0.93, 1.19, 1.56]),
18: np.array([ -1.59, -1.22, -0.97, -0.76, -0.59, -0.43, -0.28, -0.14, 0, 0.14, 0.28, 0.43, 0.59, 0.76, 0.97, 1.22, 1.59]),
19: np.array([ -1.62, -1.25, -1, -0.8, -0.63, -0.48, -0.34, -0.2, -0.07, 0.07, 0.2, 0.34, 0.48, 0.63, 0.8, 1, 1.25, 1.62]),
20: np.array([ -1.64, -1.28, -1.04, -0.84, -0.67, -0.52, -0.39, -0.25, -0.13, 0, 0.13, 0.25, 0.39, 0.52, 0.67, 0.84, 1.04, 1.28, 1.64]),
}
return options[size]
def break_points_quantiles(size):
options=np.linspace(0, 1, size+1)[1:]
return options
#y_alphabets = break_points_quantiles(y_alphabet_size).tolist()
y_alphabets = break_points_gaussian(y_alphabet_size).tolist()
def hamming_distance1(string1, string2):
distance = 0
L = len(string1)
for i in range(L):
if string1[i] != string2[i]:
distance += 1
return distance
def hamming_distance(s1, s2):
if len(s1) != len(s2):
raise ValueError("Undefined for sequences of unequal length")
return sum(el1 != el2 for el1, el2 in zip(s1, s2))
"""------------- X-axis Distribution ------------- """
def x_distrubted_values(series):
mean=np.mean(series)
#median=sorted(series)[len(series) // 2]
return mean
"""------------- Index to Letter conversion ------------- """
def index_to_letter(idx):
"""Convert a numerical index to a char."""
if 0 <= idx < 20:
return chr(97 + idx)
else:
raise ValueError('A wrong idx value supplied.')
def normalize(x):
X = np.asanyarray(x)
if np.nanstd(X) < epsilon:
res = []
for entry in X:
if not np.isnan(entry):
res.append(0)
else:
res.append(np.nan)
return res
return (X - np.nanmean(X)) / np.nanstd(X)
def normal_distribution(x):
x = (x-min(x))/(max(x)-min(x))
return x
"""------------- 1- Normalize Data ------------- """
x1=normalize(x1)
plt.plot(x1)
plt.show()
"""------------- 5.2- Y_Alphabetize ------------- """
def alphabetize_ts(sub_section):
mean_val=x_distrubted_values(sub_section)
y_alpha_val=min(y_alphabets, key=lambda x:abs(x-mean_val))
y_alpha_idx=y_alphabets.index(y_alpha_val)
curr_word = index_to_letter(y_alpha_idx)
return(curr_word)
"""------------- 2- Segmentization Data ------------- """
def segment_ts(series,windowSize=window_size,skip_offset=skip_offset):
ts_len=len(x1)
mod = ts_len%windowSize
rnge=0
if(skip_offset==0):
ts_len=int((ts_len-mod-window_size)/1)
rnge=int(ts_len/window_size)
else:
ts_len=int(math.ceil((ts_len-mod-window_size)/skip_offset))
rnge=int(ts_len)
curr_count=0
words=list()
indices=list()
complete_indices=list()
for i in range(0, rnge):
sub_section = series[curr_count:(curr_count+windowSize)]
sub_section=normalize(sub_section)
#print(curr_count,(curr_count+windowSize))
#print(sub_section)
curr_word=""
chunk_size=int(len(sub_section)/word_lenth)
num=0
zlp=""
| num+=chunk_size
words.append(zlp)
indices.append(curr_count)
curr_count=curr_count+skip_offset-1
temp_list=[]
temp_list.append(sub_section)
temp_df = pd.DataFrame(temp_list)
temp_df.insert(loc=0, column='keys', value=zlp)
temp_df.insert(loc=1, column='position', value=sorted(sub_section)[len(sub_section) // 2])
temp_df.insert(loc=2, column='scale_high', value=np.max(sub_section))
temp_df.insert(loc=3, column='scale_low', value=np.min(sub_section))
if(i==0):
df_sax =temp_df.copy()
else:
df_sax=df_sax.append(temp_df, ignore_index=True)
return (words,indices,df_sax)
alphabetize11,indices,df_sax=segment_ts(x1)
"""------------- SAX ------------- """
""" Complete Words """
def complete_word(series=x1,word_len=word_lenth,skip_len=skip_offset):
alphabetize,indices,df_sax=segment_ts(series)
complete_word=list()
| for j in range(0,word_lenth):
chunk = sub_section[num:num + chunk_size]
curr_word=alphabetize_ts(chunk)
zlp+=str(curr_word)
complete_indices.append(curr_count)
| random_line_split |
Z_normal_8_2.py | 1.15]),
9: np.array([ -1.22, -0.76, -0.43, -0.14, 0.14, 0.43, 0.76, 1.22]),
10: np.array([ -1.28, -0.84, -0.52, -0.25, 0, 0.25, 0.52, 0.84, 1.28]),
11: np.array([ -1.34, -0.91, -0.6, -0.35, -0.11, 0.11, 0.35, 0.6, 0.91, 1.34]),
12: np.array([ -1.38, -0.97, -0.67, -0.43, -0.21, 0, 0.21, 0.43, 0.67, 0.97, 1.38]),
13: np.array([ -1.43, -1.02, -0.74, -0.5, -0.29, -0.1, 0.1, 0.29, 0.5, 0.74, 1.02, 1.43]),
14: np.array([ -1.47, -1.07, -0.79, -0.57, -0.37, -0.18, 0, 0.18, 0.37, 0.57, 0.79, 1.07, 1.47]),
15: np.array([ -1.5, -1.11, -0.84, -0.62, -0.43, -0.25, -0.08, 0.08, 0.25, 0.43, 0.62, 0.84, 1.11, 1.5]),
16: np.array([ -1.53, -1.15, -0.89, -0.67, -0.49, -0.32, -0.16, 0, 0.16, 0.32, 0.49, 0.67, 0.89, 1.15, 1.53]),
17: np.array([ -1.56, -1.19, -0.93, -0.72, -0.54, -0.38, -0.22, -0.07, 0.07, 0.22, 0.38, 0.54, 0.72, 0.93, 1.19, 1.56]),
18: np.array([ -1.59, -1.22, -0.97, -0.76, -0.59, -0.43, -0.28, -0.14, 0, 0.14, 0.28, 0.43, 0.59, 0.76, 0.97, 1.22, 1.59]),
19: np.array([ -1.62, -1.25, -1, -0.8, -0.63, -0.48, -0.34, -0.2, -0.07, 0.07, 0.2, 0.34, 0.48, 0.63, 0.8, 1, 1.25, 1.62]),
20: np.array([ -1.64, -1.28, -1.04, -0.84, -0.67, -0.52, -0.39, -0.25, -0.13, 0, 0.13, 0.25, 0.39, 0.52, 0.67, 0.84, 1.04, 1.28, 1.64]),
}
return options[size]
def break_points_quantiles(size):
options=np.linspace(0, 1, size+1)[1:]
return options
#y_alphabets = break_points_quantiles(y_alphabet_size).tolist()
y_alphabets = break_points_gaussian(y_alphabet_size).tolist()
def hamming_distance1(string1, string2):
distance = 0
L = len(string1)
for i in range(L):
if string1[i] != string2[i]:
distance += 1
return distance
def hamming_distance(s1, s2):
if len(s1) != len(s2):
raise ValueError("Undefined for sequences of unequal length")
return sum(el1 != el2 for el1, el2 in zip(s1, s2))
"""------------- X-axis Distribution ------------- """
def x_distrubted_values(series):
mean=np.mean(series)
#median=sorted(series)[len(series) // 2]
return mean
"""------------- Index to Letter conversion ------------- """
def index_to_letter(idx):
"""Convert a numerical index to a char."""
if 0 <= idx < 20:
|
else:
raise ValueError('A wrong idx value supplied.')
def normalize(x):
X = np.asanyarray(x)
if np.nanstd(X) < epsilon:
res = []
for entry in X:
if not np.isnan(entry):
res.append(0)
else:
res.append(np.nan)
return res
return (X - np.nanmean(X)) / np.nanstd(X)
def normal_distribution(x):
x = (x-min(x))/(max(x)-min(x))
return x
"""------------- 1- Normalize Data ------------- """
x1=normalize(x1)
plt.plot(x1)
plt.show()
"""------------- 5.2- Y_Alphabetize ------------- """
def alphabetize_ts(sub_section):
mean_val=x_distrubted_values(sub_section)
y_alpha_val=min(y_alphabets, key=lambda x:abs(x-mean_val))
y_alpha_idx=y_alphabets.index(y_alpha_val)
curr_word = index_to_letter(y_alpha_idx)
return(curr_word)
"""------------- 2- Segmentization Data ------------- """
def segment_ts(series,windowSize=window_size,skip_offset=skip_offset):
ts_len=len(x1)
mod = ts_len%windowSize
rnge=0
if(skip_offset==0):
ts_len=int((ts_len-mod-window_size)/1)
rnge=int(ts_len/window_size)
else:
ts_len=int(math.ceil((ts_len-mod-window_size)/skip_offset))
rnge=int(ts_len)
curr_count=0
words=list()
indices=list()
complete_indices=list()
for i in range(0, rnge):
sub_section = series[curr_count:(curr_count+windowSize)]
sub_section=normalize(sub_section)
#print(curr_count,(curr_count+windowSize))
#print(sub_section)
curr_word=""
chunk_size=int(len(sub_section)/word_lenth)
num=0
zlp=""
for j in range(0,word_lenth):
chunk = sub_section[num:num + chunk_size]
curr_word=alphabetize_ts(chunk)
zlp+=str(curr_word)
complete_indices.append(curr_count)
num+=chunk_size
words.append(zlp)
indices.append(curr_count)
curr_count=curr_count+skip_offset-1
temp_list=[]
temp_list.append(sub_section)
temp_df = pd.DataFrame(temp_list)
temp_df.insert(loc=0, column='keys', value=zlp)
temp_df.insert(loc=1, column='position', value=sorted(sub_section)[len(sub_section) // 2])
temp_df.insert(loc=2, column='scale_high', value=np.max(sub_section))
temp_df.insert(loc=3, column='scale_low', value=np.min(sub_section))
if(i==0):
df_sax =temp_df.copy()
else:
df_sax=df_sax.append(temp_df, ignore_index=True)
return (words,indices,df_sax)
alphabetize11,indices,df_sax=segment_ts(x1)
"""------------- SAX ------------- """
""" Complete Words """
def complete_word(series=x1,word_len=word_lenth,skip_len=skip_offset):
alphabetize,indices,df_sax=segment_ts(series)
complete_word=list()
| return chr(97 + idx) | conditional_block |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.