45271a2dcda8123130d2b8a8de38e3eba2fba68c
|
|
|
|
Sources/servermodel/LoginTokenDAO.swift
|
|
1bc4b4e7868b056eef30adece3878e2b80e4511c
|
|
|
|
|
Sources/servermodel/LoginTokenDAO.swift
|
|
1bc4b4e7868b056eef30adece3878e2b80e4511c
|
|
|
|
|
Sources/servermodel/LoginTokenDAO.swift
|
|
1bc4b4e7868b056eef30adece3878e2b80e4511c
|
|
|
|
|
//
// LoginTokenDAO.swift
//
// Copyright ©2017 Mark Lilback. This file is licensed under the ISC license.
//
import Foundation
import pgswift
import Rc2Model
import Logging
import SwiftJWT
/// Simple wrapper around contents stored in the authentication token
public struct LoginToken: Codable, Claims {
public let id: Int
public let userId: Int
public init?(_ dict: [String: Any]) {
guard let inId = dict["token"] as? Int, let inUser = dict["user"] as? Int else { return nil }
id = inId
userId = inUser
}
public init(_ inId: Int, _ inUser: Int) {
id = inId
userId = inUser
}
public var contents: [String: Any] { return ["token": id, "user": userId] }
}
/// Wrapper for database actions related to login tokens
public final class LoginTokenDAO {
private let pgdb: Connection
/// create a DAO
///
/// - Parameter connection: the database to query
public init(connection: Connection) {
pgdb = connection
}
/// create a new login token for a user
///
/// - Parameter user: the user to create a token for
/// - Returns: a new token
/// - Throws: a .dbError if the sql command fails
public func createToken(user: User) throws -> LoginToken {
do {
let result = try pgdb.execute(query: "insert into logintoken (userId) values ($1) returning id", parameters: [QueryParameter(type: .int8, value: user.id, connection: pgdb)])
guard result.wasSuccessful, result.rowCount == 1 else { throw ModelError.dbError }
guard let tokenId: Int = try result.getValue(row: 0, column: 0)
else { throw ModelError.dbError }
return LoginToken(tokenId, user.id)
} catch {
logger.error("failed to insert logintoken \(error)")
throw ModelError.dbError
}
}
/// checks the database to make sure a token is still valid
///
/// - Parameter token: the token to check
/// - Returns: true if the token is still valid
public func validate(token: LoginToken) -> Bool {
do {
let params: [QueryParameter] = [ try QueryParameter(type: .int8, value: token.id, connection: pgdb), try QueryParameter(type: .int8, value: token.userId, connection: pgdb) ]
let result = try? pgdb.execute(query: "select * from logintoken where id = $1 and userId = $2 and valid = true", parameters: params)
guard let res = result, res.wasSuccessful, res.rowCount == 1 else {
logger.info("failed to validate token for user \(token.userId)")
return false
}
return true
} catch {
logger.warning("validateLoginToken failed: \(error)")
return false
}
}
/// invalidate a token so it can't be used again
///
/// - Parameter token: the token to invalidate
/// - Throws: errors from executing sql
public func invalidate(token: LoginToken) throws {
let query = "update logintoken set valid = false where id = $1 and userId = $2"
let params: [QueryParameter] = [ try QueryParameter(type: .int8, value: token.id, connection: pgdb), try QueryParameter(type: .int8, value: token.userId, connection: pgdb) ]
let results = try pgdb.execute(query: query, parameters: params)
guard results.wasSuccessful else {
logger.warning("failed to invalidate token: \(results.errorMessage)")
throw ModelError.dbError
}
}
}
|
|
|
|
|
0ce5cb9e4bc10393a6546a397038a2d745082f63
|
|
|
|
|
|
68b04bfd55082862f419031c28e7b52f1800f3db
|
|
|
|
|
|
|
68b04bfd55082862f419031c28e7b52f1800f3db
|
|
|
|
|
|
|
68b04bfd55082862f419031c28e7b52f1800f3db
|
|
|
|
|
#!/usr/bin/env python
u"""
read_iceye_h5.py
Written by Enrico Ciraci' (03/2022)
Read ICEYE Single Look Complex and Parameter file using GAMMA's Python
integration with the py_gamma module.
usage: read_iceye_h5.py [-h] [--directory DIRECTORY]
TEST: Read ICEye Single Look Complex and Parameter.
optional arguments:
-h, --help show this help message and exit
--directory DIRECTORY, -D DIRECTORY
Project data directory.
--slc SLC, -C SLC Process and single SLC.
PYTHON DEPENDENCIES:
argparse: Parser for command-line options, arguments and sub-commands
https://docs.python.org/3/library/argparse.html
datetime: Basic date and time types
https://docs.python.org/3/library/datetime.html#module-datetime
tqdm: Progress Bar in Python.
https://tqdm.github.io/
py_gamma: GAMMA's Python integration with the py_gamma module
UPDATE HISTORY:
"""
# - Python Dependencies
from __future__ import print_function
import os
import argparse
import datetime
from tqdm import tqdm
# - GAMMA's Python integration with the py_gamma module
import py_gamma as pg
# - Utility Function
from utils.make_dir import make_dir
def main():
parser = argparse.ArgumentParser(
description="""TEST: Read ICEye Single Look Complex and Parameter."""
)
# - Absolute Path to directory containing input data.
default_dir = os.path.join(os.path.expanduser('~'), 'Desktop',
'iceye_gamma_test')
parser.add_argument('--directory', '-D',
type=lambda p: os.path.abspath(os.path.expanduser(p)),
default=default_dir,
help='Project data directory.')
parser.add_argument('--slc', '-C', type=str,
default=None, help='Process and single SLC.')
args = parser.parse_args()
# - Path to Test directory
data_dir = os.path.join(args.directory, 'input')
# - create output directory
out_dir = make_dir(args.directory, 'output')
out_dir = make_dir(out_dir, 'slc+par')
# - ICEye Suffix
ieye_suff = 'ICEYE_X7_SLC_SM_'
if args.slc is not None:
# - Process a single SLC
b_input = os.path.join(data_dir, args.slc)
# - Read input Binary File Name
b_input_name = b_input.split('/')[-1].replace(ieye_suff, '')
slc_name = os.path.join(out_dir,
str(b_input_name.replace('.h5', '.slc')))
par_name = os.path.join(out_dir,
str(b_input_name.replace('.h5', '.par')))
# - Extract SLC and Parameter File
# - Set dtype equal to zero to save the SLC in FCOMPLEX format.
pg.par_ICEYE_SLC(b_input, par_name, slc_name, 0)
else:
# - Process hte entire input directory content
# - List Directory Content
data_dir_list = [os.path.join(data_dir, x) for x in os.listdir(data_dir)
if x.endswith('.h5')]
for b_input in tqdm(data_dir_list, total=len(data_dir_list), ncols=60):
# - Read input Binary File Name
b_input_name = b_input.split('/')[-1].replace(ieye_suff, '')
slc_name = os.path.join(out_dir, b_input_name.replace('.h5', '.slc'))
par_name = os.path.join(out_dir, b_input_name.replace('.h5', '.par'))
# - Extract SLC and Parameter File
# - Set dtype equal to zero to save the SLC in FCOMPLEX format.
pg.par_ICEYE_SLC(b_input, par_name, slc_name, 0)
# - run main program
if __name__ == '__main__':
start_time = datetime.datetime.now()
main()
end_time = datetime.datetime.now()
print(f"# - Computation Time: {end_time - start_time}")
|
|
|
|
|
b82b91a8c8452384a38b315df5c298b27dc87504
|
|
|
|
|
|
088482d47afb4753f5f13a788b54703cd61407f7
|
|
|
|
|
|
|
088482d47afb4753f5f13a788b54703cd61407f7
|
|
|
|
|
|
|
088482d47afb4753f5f13a788b54703cd61407f7
|
|
|
|
|
use crate::ray::Ray;
use crate::vec3::Vec3;
#[derive(Clone, Copy)]
pub struct AABB {
pub minimum: Vec3,
pub maximum: Vec3,
}
impl AABB {
pub fn new(minimum: Vec3, maximum: Vec3) -> Self {
AABB { minimum, maximum }
}
pub fn hit(&self, ray: &Ray, mut t_min: f64, mut t_max: f64) -> bool {
for a in 0..=2 {
let inv_d = 1.0 / ray.direction[a];
let mut t0 = (self.minimum[a] - ray.origin[a]) * inv_d;
let mut t1 = (self.maximum[a] - ray.origin[a]) * inv_d;
if inv_d < 0.0 {
std::mem::swap(&mut t0, &mut t1);
}
t_min = if t0 > t_min { t0 } else { t_min };
t_max = if t1 < t_max { t1 } else { t_max };
if t_max <= t_min {
return false;
}
}
true
}
pub fn bounding_box(box0: &AABB, box1: &AABB) -> AABB {
let small = Vec3::new(
box0.minimum.x.min(box1.minimum.x),
box0.minimum.y.min(box1.minimum.y),
box0.minimum.z.min(box1.minimum.z),
);
let big = Vec3::new(
box0.maximum.x.max(box1.maximum.x),
box0.maximum.y.max(box1.maximum.y),
box0.maximum.z.max(box1.maximum.z),
);
AABB::new(small, big)
}
}
|
|
|
|
|
264ead018108520a8478776c35bf7acb0a7da8da
|
|
|
|
ch7-hbase/src/main/java/ch7/CH711GenderCount.java
|
|
d51faf1bddf5d29984f1ea5cfa7bdf4a2847e692
|
|
|
|
|
ch7-hbase/src/main/java/ch7/CH711GenderCount.java
|
|
d51faf1bddf5d29984f1ea5cfa7bdf4a2847e692
|
|
|
|
|
ch7-hbase/src/main/java/ch7/CH711GenderCount.java
|
|
d51faf1bddf5d29984f1ea5cfa7bdf4a2847e692
|
|
|
|
|
package ch7;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
public class CH711GenderCount extends CH701HBaseBase {
@Override
public void run() throws IOException {
Scan scan = new Scan();
scan.addColumn(Bytes.toBytes("data"),Bytes.toBytes("gender"));
Table table = conn.getTable(TableName.valueOf("students"));
ResultScanner resultScanner = table.getScanner(scan);
int maleCount=0,femaleCount=0;
for(Result result : resultScanner){
String gender = Bytes.toString(result.getValue(Bytes.toBytes("data"),Bytes.toBytes("gender")));
if(gender.equals("男")){
maleCount++;
} else {
femaleCount++;
}
}
System.out.println("男生人数："+maleCount);
System.out.println("女生人数："+femaleCount);
conn.close();
}
public static void main(String[] args) throws IOException {
new CH711GenderCount().run();
}
}
|
|
|
|
|
0ca33e888a8c5506799931e71fe1070bf6588145
|
|
|
|
|
|
0da122bea9b7bd51444748444700b5f788bd8a48
|
|
|
|
|
|
|
0da122bea9b7bd51444748444700b5f788bd8a48
|
|
|
|
|
|
|
0da122bea9b7bd51444748444700b5f788bd8a48
|
|
|
|
|
import numpy as np
import sys
import utils
import os
from collections import defaultdict
from nltk.corpus import wordnet as wn
from scipy.spatial.distance import cosine
from scipy.spatial.distance import correlation
from numpy.linalg import norm
from scipy.stats import spearmanr, pearsonr
from utils import trim
import pdb
"""
Sense embedding format: see https://github.com/sjauhar/SenseRetrofit
Use ',' to seperate Datasets
"""
def run(path, fname):
'''
if len(sys.argv) != 3:
print("Usage: python we_sensesim.py SenseEmbedding Datasets")
exit(0)
'''
#wvs = utils.readWordVecs(os.path.expanduser(full_path))
wvs = utils.readWordVecs(sys.argv[1])
print("Finish reading vector!")
wvssen = {}
s_list = defaultdict(list)
for sense in wvs:
wvssen[sense.split("%")[0]] = ''
s_list[sense.split("%")[0]].append(sense)
mean_vector = np.mean(wvs.values(), axis=0)
spear_score_max = []
spear_score_avg = []
f_name = []
for name in fname:
full_path = os.path.join(path, name)
filenames = os.path.expanduser(full_path).split(',')
pairs, scores = utils.readDataset(filenames[0], no_skip=True)
#f_name.append(filenames[0])
#print("Pair number for %s: %d"%(filenames[0], len(pairs)))
coefs_max = []
coefs_avg = []
missing = 0
for pair in pairs:
vecs0 = []
trimed_p0 = trim(pair[0], wvssen)
if trimed_p0 not in wvssen:
vecs0.append(mean_vector)
missing += 1
#print trimed_p0,
else:
for sense in s_list[trimed_p0]:
vecs0.append(wvs[sense])
'''
for sense in wvs:
word = sense.split("%")[0]
if trimed_p0 == word:
vecs0.append(wvs[sense])
'''
vecs1 = []
trimed_p1 = trim(pair[1],wvssen)
if trimed_p1 not in wvssen:
vecs1.append(mean_vector)
missing += 1
#print trimed_p1,
else:
for sense in s_list[trimed_p1]:
vecs1.append(wvs[sense])
'''
for sense in wvs:
word = sense.split("%")[0]
if trimed_p1 == word:
vecs1.append(wvs[sense])
'''
'''
max_value and avg_value: see "Multi-Prototype Vector-Space Models of Word Meaning" section 3.2 Measuring Semantic Similarity
http://www.cs.utexas.edu/~ml/papers/reisinger.naacl-2010.pdf
'''
max_value = max([1-cosine(a,b) for a in vecs0 for b in vecs1])
avg_value = np.mean([1-cosine(a,b) for a in vecs0 for b in vecs1])
coefs_max.append(max_value)
coefs_avg.append(avg_value)
spear_max = spearmanr(scores, coefs_max)
pearson_max = pearsonr(scores, coefs_max)
spear_avg = spearmanr(scores, coefs_avg)
pearson_avg = pearsonr(scores, coefs_avg)
spear_score_max.append(spear_max[0])
spear_score_avg.append(spear_avg[0])
print 'type \t',
for i in range(len(fname)):
print fname[i].split('.')[0],
print '\nspear max\t',
for i in range(len(fname)):
print '%.04f,' % (spear_score_max[i]),
print '\nspear avg\t',
for i in range(len(fname)):
print '%.04f,' % (spear_score_avg[i]),
if __name__ == "__main__":
run('./eval_data', ['EN-MEN-n.txt', 'EN-MEN-l.txt', 'EN-TRUK.txt', 'EN-RW.txt', 'EN-WS353.txt', 'EN-WS353-s.txt', 'EN-WS353-r.txt'])
|
|
|
|
|
de9e3cbfeb9caee6164895e5e997e0101d3ff54f
|
|
|
|
frb_codegen/src/source_graph.rs
|
AlienKevin/flutter_rust_bridge
|
37ebac9f0ec26a1293374640d52a8b6f4e8bc277
|
|
|
|
|
frb_codegen/src/source_graph.rs
|
AlienKevin/flutter_rust_bridge
|
37ebac9f0ec26a1293374640d52a8b6f4e8bc277
|
|
|
|
|
frb_codegen/src/source_graph.rs
|
AlienKevin/flutter_rust_bridge
|
37ebac9f0ec26a1293374640d52a8b6f4e8bc277
|
|
|
|
|
/*
Things this doesn't currently support that it might need to later:
- Import parsing is unfinished and so is currently disabled
- When import parsing is enabled:
- Import renames (use a::b as c) - these are silently ignored
- Imports that start with two colons (use ::a::b) - these are also silently ignored
*/
use std::{collections::HashMap, fmt::Debug, fs, path::PathBuf};
use cargo_metadata::MetadataCommand;
use log::{debug, warn};
use syn::{Attribute, Ident, ItemEnum, ItemStruct, UseTree};
use crate::markers;
/// Represents a crate, including a map of its modules, imports, structs and
/// enums.
#[derive(Debug, Clone)]
pub struct Crate {
pub name: String,
pub manifest_path: PathBuf,
pub root_src_file: PathBuf,
pub root_module: Module,
}
impl Crate {
pub fn new(manifest_path: &str) -> Self {
let mut cmd = MetadataCommand::new();
cmd.manifest_path(&manifest_path);
let metadata = cmd.exec().unwrap();
let root_package = metadata.root_package().unwrap();
let root_src_file = {
let lib_file = root_package
.manifest_path
.parent()
.unwrap()
.join("src/lib.rs");
let main_file = root_package
.manifest_path
.parent()
.unwrap()
.join("src/main.rs");
if lib_file.exists() {
fs::canonicalize(lib_file).unwrap()
} else if main_file.exists() {
fs::canonicalize(main_file).unwrap()
} else {
panic!("No src/lib.rs or src/main.rs found for this Cargo.toml file");
}
};
let source_rust_content = fs::read_to_string(&root_src_file).unwrap();
let file_ast = syn::parse_file(&source_rust_content).unwrap();
let mut result = Crate {
name: root_package.name.clone(),
manifest_path: fs::canonicalize(manifest_path).unwrap(),
root_src_file: root_src_file.clone(),
root_module: Module {
visibility: Visibility::Public,
file_path: root_src_file,
module_path: vec!["crate".to_string()],
source: Some(ModuleSource::File(file_ast)),
scope: None,
},
};
result.resolve();
result
}
/// Create a map of the modules for this crate
pub fn resolve(&mut self) {
self.root_module.resolve();
}
}
/// Mirrors syn::Visibility, but can be created without a token
#[derive(Debug, Clone)]
pub enum Visibility {
Public,
Crate,
Restricted, // Not supported
Inherited, // Usually means private
}
fn syn_vis_to_visibility(vis: &syn::Visibility) -> Visibility {
match vis {
syn::Visibility::Public(_) => Visibility::Public,
syn::Visibility::Crate(_) => Visibility::Crate,
syn::Visibility::Restricted(_) => Visibility::Restricted,
syn::Visibility::Inherited => Visibility::Inherited,
}
}
#[derive(Debug, Clone)]
pub struct Import {
pub path: Vec<String>,
pub visibility: Visibility,
}
#[derive(Debug, Clone)]
pub enum ModuleSource {
File(syn::File),
ModuleInFile(Vec<syn::Item>),
}
#[derive(Clone)]
pub struct Struct {
pub ident: Ident,
pub src: ItemStruct,
pub visibility: Visibility,
pub path: Vec<String>,
pub mirror: bool,
}
impl Debug for Struct {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Struct")
.field("ident", &self.ident)
.field("src", &"omitted")
.field("visibility", &self.visibility)
.field("path", &self.path)
.field("mirror", &self.mirror)
.finish()
}
}
#[derive(Clone)]
pub struct Enum {
pub ident: Ident,
pub src: ItemEnum,
pub visibility: Visibility,
pub path: Vec<String>,
pub mirror: bool,
}
impl Debug for Enum {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Enum")
.field("ident", &self.ident)
.field("src", &"omitted")
.field("visibility", &self.visibility)
.field("path", &self.path)
.field("mirror", &self.mirror)
.finish()
}
}
#[derive(Debug, Clone)]
pub struct ModuleScope {
pub modules: Vec<Module>,
pub enums: Vec<Enum>,
pub structs: Vec<Struct>,
pub imports: Vec<Import>,
}
#[derive(Clone)]
pub struct Module {
pub visibility: Visibility,
pub file_path: PathBuf,
pub module_path: Vec<String>,
pub source: Option<ModuleSource>,
pub scope: Option<ModuleScope>,
}
impl Debug for Module {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Module")
.field("visibility", &self.visibility)
.field("module_path", &self.module_path)
.field("file_path", &self.file_path)
.field("source", &"omitted")
.field("scope", &self.scope)
.finish()
}
}
/// Get a struct or enum ident, possibly remapped by a mirror marker
fn get_ident(ident: &Ident, attrs: &[Attribute]) -> (Ident, bool) {
markers::extract_mirror_marker(attrs)
.and_then(|path| path.get_ident().map(|ident| (ident.clone(), true)))
.unwrap_or_else(|| (ident.clone(), false))
}
impl Module {
pub fn resolve(&mut self) {
self.resolve_modules();
// self.resolve_imports();
}
/// Maps out modules, structs and enums within the scope of this module
fn resolve_modules(&mut self) {
let mut scope_modules = Vec::new();
let mut scope_structs = Vec::new();
let mut scope_enums = Vec::new();
let items = match self.source.as_ref().unwrap() {
ModuleSource::File(file) => &file.items,
ModuleSource::ModuleInFile(items) => items,
};
for item in items.iter() {
match item {
syn::Item::Struct(item_struct) => {
let (ident, mirror) = get_ident(&item_struct.ident, &item_struct.attrs);
let ident_str = ident.to_string();
scope_structs.push(Struct {
ident,
src: item_struct.clone(),
visibility: syn_vis_to_visibility(&item_struct.vis),
path: {
let mut path = self.module_path.clone();
path.push(ident_str);
path
},
mirror,
});
}
syn::Item::Enum(item_enum) => {
let (ident, mirror) = get_ident(&item_enum.ident, &item_enum.attrs);
let ident_str = ident.to_string();
scope_enums.push(Enum {
ident,
src: item_enum.clone(),
visibility: syn_vis_to_visibility(&item_enum.vis),
path: {
let mut path = self.module_path.clone();
path.push(ident_str);
path
},
mirror,
});
}
syn::Item::Mod(item_mod) => {
let ident = item_mod.ident.clone();
let mut module_path = self.module_path.clone();
module_path.push(ident.to_string());
scope_modules.push(match &item_mod.content {
Some(content) => {
let mut child_module = Module {
visibility: syn_vis_to_visibility(&item_mod.vis),
file_path: self.file_path.clone(),
module_path,
source: Some(ModuleSource::ModuleInFile(content.1.clone())),
scope: None,
};
child_module.resolve();
child_module
}
None => {
let folder_path =
self.file_path.parent().unwrap().join(ident.to_string());
let folder_exists = folder_path.exists();
let file_path = if folder_exists {
folder_path.join("mod.rs")
} else {
self.file_path
.parent()
.unwrap()
.join(ident.to_string() + ".rs")
};
let file_exists = file_path.exists();
if !file_exists {
warn!(
"Skipping unresolvable module {} (tried {})",
&ident,
file_path.to_string_lossy()
);
continue;
}
let source = if file_exists {
let source_rust_content = fs::read_to_string(&file_path).unwrap();
debug!("Trying to parse {:?}", file_path);
Some(ModuleSource::File(
syn::parse_file(&source_rust_content).unwrap(),
))
} else {
None
};
let mut child_module = Module {
visibility: syn_vis_to_visibility(&item_mod.vis),
file_path,
module_path,
source,
scope: None,
};
if file_exists {
child_module.resolve();
}
child_module
}
});
}
_ => {}
}
}
self.scope = Some(ModuleScope {
modules: scope_modules,
enums: scope_enums,
structs: scope_structs,
imports: vec![], // Will be filled in by resolve_imports()
});
}
#[allow(dead_code)]
fn resolve_imports(&mut self) {
let imports = &mut self.scope.as_mut().unwrap().imports;
let items = match self.source.as_ref().unwrap() {
ModuleSource::File(file) => &file.items,
ModuleSource::ModuleInFile(items) => items,
};
for item in items.iter() {
if let syn::Item::Use(item_use) = item {
let flattened_imports = flatten_use_tree(&item_use.tree);
for import in flattened_imports {
imports.push(Import {
path: import,
visibility: syn_vis_to_visibility(&item_use.vis),
});
}
}
}
}
pub fn collect_structs<'a>(&'a self, container: &mut HashMap<String, &'a Struct>) {
let scope = self.scope.as_ref().unwrap();
for scope_struct in &scope.structs {
container.insert(scope_struct.ident.to_string(), scope_struct);
}
for scope_module in &scope.modules {
scope_module.collect_structs(container);
}
}
pub fn collect_structs_to_vec(&self) -> HashMap<String, &Struct> {
let mut ans = HashMap::new();
self.collect_structs(&mut ans);
ans
}
pub fn collect_enums<'a>(&'a self, container: &mut HashMap<String, &'a Enum>) {
let scope = self.scope.as_ref().unwrap();
for scope_enum in &scope.enums {
container.insert(scope_enum.ident.to_string(), scope_enum);
}
for scope_module in &scope.modules {
scope_module.collect_enums(container);
}
}
pub fn collect_enums_to_vec(&self) -> HashMap<String, &Enum> {
let mut ans = HashMap::new();
self.collect_enums(&mut ans);
ans
}
}
fn flatten_use_tree_rename_abort_warning(use_tree: &UseTree) {
debug!("WARNING: flatten_use_tree() found an import rename (use a::b as c). flatten_use_tree() will now abort.");
debug!("WARNING: This happened while parsing {:?}", use_tree);
debug!("WARNING: This use statement will be ignored.");
}
/// Takes a use tree and returns a flat list of use paths (list of string tokens)
///
/// Example:
/// use a::{b::c, d::e};
/// becomes
/// [
/// ["a", "b", "c"],
/// ["a", "d", "e"]
/// ]
///
/// Warning: As of writing, import renames (import a::b as c) are silently
/// ignored.
fn flatten_use_tree(use_tree: &UseTree) -> Vec<Vec<String>> {
// Vec<(path, is_complete)>
let mut result = vec![(vec![], false)];
let mut counter: usize = 0;
loop {
counter += 1;
if counter > 10000 {
panic!("flatten_use_tree: Use statement complexity limit exceeded. This is probably a bug.");
}
// If all paths are complete, break from the loop
if result.iter().all(|result_item| result_item.1) {
break;
}
let mut items_to_push = Vec::new();
for path_tuple in &mut result {
let path = &mut path_tuple.0;
let is_complete = &mut path_tuple.1;
if *is_complete {
continue;
}
let mut tree_cursor = use_tree;
for path_item in path.iter() {
match tree_cursor {
UseTree::Path(use_path) => {
let ident = use_path.ident.to_string();
if *path_item != ident {
panic!("This ident did not match the one we already collected. This is a bug.");
}
tree_cursor = use_path.tree.as_ref();
}
UseTree::Group(use_group) => {
let mut moved_tree_cursor = false;
for tree in use_group.items.iter() {
match tree {
UseTree::Path(use_path) => {
if path_item == &use_path.ident.to_string() {
tree_cursor = use_path.tree.as_ref();
moved_tree_cursor = true;
break;
}
}
// Since we're not matching UseTree::Group here, a::b::{{c}, {d}} might
// break. But also why would anybody do that
_ => unreachable!(),
}
}
if !moved_tree_cursor {
unreachable!();
}
}
_ => unreachable!(),
}
}
match tree_cursor {
UseTree::Name(use_name) => {
path.push(use_name.ident.to_string());
*is_complete = true;
}
UseTree::Path(use_path) => {
path.push(use_path.ident.to_string());
}
UseTree::Glob(_) => {
path.push("*".to_string());
*is_complete = true;
}
UseTree::Group(use_group) => {
// We'll modify the first one in-place, and make clones for
// all subsequent ones
let mut first: bool = true;
// Capture the path in this state, since we're about to
// modify it
let path_copy = path.clone();
for tree in use_group.items.iter() {
let mut new_path_tuple = if first {
None
} else {
let new_path = path_copy.clone();
items_to_push.push((new_path, false));
Some(items_to_push.iter_mut().last().unwrap())
};
match tree {
UseTree::Path(use_path) => {
let ident = use_path.ident.to_string();
if first {
path.push(ident);
} else {
new_path_tuple.unwrap().0.push(ident);
}
}
UseTree::Name(use_name) => {
let ident = use_name.ident.to_string();
if first {
path.push(ident);
*is_complete = true;
} else {
let path_tuple = new_path_tuple.as_mut().unwrap();
path_tuple.0.push(ident);
path_tuple.1 = true;
}
}
UseTree::Glob(_) => {
if first {
path.push("*".to_string());
*is_complete = true;
} else {
let path_tuple = new_path_tuple.as_mut().unwrap();
path_tuple.0.push("*".to_string());
path_tuple.1 = true;
}
}
UseTree::Group(_) => {
panic!(
"Directly-nested use groups ({}) are not supported by flutter_rust_bridge. Use {} instead.",
"use a::{{b}, c}",
"a::{b, c}"
);
}
// UseTree::Group(_) => panic!(),
UseTree::Rename(_) => {
flatten_use_tree_rename_abort_warning(use_tree);
return vec![];
}
}
first = false;
}
}
UseTree::Rename(_) => {
flatten_use_tree_rename_abort_warning(use_tree);
return vec![];
}
}
}
for item in items_to_push {
result.push(item);
}
}
result.into_iter().map(|val| val.0).collect()
}
|
|
|
|
|
dd11dbd635362054dadd3b141f67a6cc9f5b54bc
|
|
|
|
environment/container/kubernetes/kubernetes.go
|
|
d99e306af18b4459ea1562434899756b234816d6
|
|
|
|
|
environment/container/kubernetes/kubernetes.go
|
|
d99e306af18b4459ea1562434899756b234816d6
|
|
|
|
|
environment/container/kubernetes/kubernetes.go
|
|
d99e306af18b4459ea1562434899756b234816d6
|
|
|
|
|
package kubernetes
import (
"strings"
"time"
"github.com/abiosoft/colima/cli"
"github.com/abiosoft/colima/config"
"github.com/abiosoft/colima/environment"
"github.com/abiosoft/colima/environment/container/containerd"
"github.com/abiosoft/colima/environment/container/docker"
)
// Name is container runtime name
const Name = "kubernetes"
func newRuntime(host environment.HostActions, guest environment.GuestActions) environment.Container {
return &kubernetesRuntime{
host: host,
guest: guest,
CommandChain: cli.New(Name),
}
}
func init() {
environment.RegisterContainer(Name, newRuntime)
}
var _ environment.Container = (*kubernetesRuntime)(nil)
type kubernetesRuntime struct {
host environment.HostActions
guest environment.GuestActions
cli.CommandChain
}
func (c kubernetesRuntime) Name() string {
return Name
}
func (c kubernetesRuntime) isInstalled() bool {
// it is installed if uninstall script is present.
return c.guest.RunQuiet("command", "-v", "k3s-uninstall.sh") == nil
}
func (c kubernetesRuntime) Running() bool {
return c.guest.RunQuiet("sudo", "service", "k3s", "status") == nil
}
func (c kubernetesRuntime) runtime() string {
return c.guest.Get(environment.ContainerRuntimeKey)
}
func (c kubernetesRuntime) kubernetesVersion() string {
return c.guest.Get(environment.KubernetesVersionKey)
}
func (c *kubernetesRuntime) Provision() error {
a := c.Init()
if !c.isInstalled() {
// k3s
a.Stage("downloading and installing")
installK3s(c.host, c.guest, a, c.runtime())
}
// this needs to happen on each startup
if c.runtime() == containerd.Name {
installContainerdDeps(c.guest, a)
}
return a.Exec()
}
func (c kubernetesRuntime) Start() error {
log := c.Logger()
a := c.Init()
if c.Running() {
log.Println("already running")
return nil
}
a.Stage("starting")
a.Add(func() error {
defer time.Sleep(time.Second * 5)
return c.guest.Run("sudo", "service", "k3s", "start")
})
if err := a.Exec(); err != nil {
return err
}
return c.provisionKubeconfig()
}
func (c kubernetesRuntime) Stop() error {
a := c.Init()
a.Stage("stopping")
a.Add(func() error {
return c.guest.Run("k3s-killall.sh")
})
// k3s is buggy with external containerd for now
// cleanup is manual
a.Add(c.stopAllContainers)
return a.Exec()
}
func (c kubernetesRuntime) deleteAllContainers() error {
ids := c.runningContainerIDs()
if ids == "" {
return nil
}
var args []string
switch c.runtime() {
case containerd.Name:
args = []string{"nerdctl", "-n", "k8s.io", "rm", "-f"}
case docker.Name:
args = []string{"docker", "rm", "-f"}
default:
return nil
}
args = append(args, strings.Fields(ids)...)
return c.guest.Run("sudo", "sh", "-c", strings.Join(args, " "))
}
func (c kubernetesRuntime) stopAllContainers() error {
ids := c.runningContainerIDs()
if ids == "" {
return nil
}
var args []string
switch c.runtime() {
case containerd.Name:
args = []string{"nerdctl", "-n", "k8s.io", "kill"}
case docker.Name:
args = []string{"docker", "kill"}
default:
return nil
}
args = append(args, strings.Fields(ids)...)
return c.guest.Run("sudo", "sh", "-c", strings.Join(args, " "))
}
func (c kubernetesRuntime) runningContainerIDs() string {
var args []string
switch c.runtime() {
case containerd.Name:
args = []string{"sudo", "nerdctl", "-n", "k8s.io", "ps", "-q"}
case docker.Name:
args = []string{"sudo", "sh", "-c", `docker ps --format '{{.Names}}'| grep "k8s_"`}
default:
return ""
}
ids, _ := c.guest.RunOutput(args...)
if ids == "" {
return ""
}
return strings.ReplaceAll(ids, "\n", " ")
}
func (c kubernetesRuntime) Teardown() error {
a := c.Init()
a.Stage("deleting")
if c.isInstalled() {
a.Add(func() error {
return c.guest.Run("k3s-uninstall.sh")
})
}
// k3s is buggy with external containerd for now
// cleanup is manual
a.Add(func() error {
return c.deleteAllContainers()
})
c.teardownKubeconfig(a)
a.Add(func() error {
return c.guest.Set(kubeconfigKey, "")
})
return a.Exec()
}
func (c kubernetesRuntime) Dependencies() []string {
return []string{"kubectl"}
}
func (c kubernetesRuntime) Version() string {
version, _ := c.host.RunOutput("kubectl", "--context", config.Profile().ID, "version", "--short")
return version
}
|
|
|
|
|
583829c19d32bffd2c4e6c97031c45f243db0563
|
|
|
|
|
he110world/libmeh_working
|
0f324dabdf2dcfc67b18f64acb7d9629aed1c04f
|
|
|
|
|
|
he110world/libmeh_working
|
0f324dabdf2dcfc67b18f64acb7d9629aed1c04f
|
|
|
|
|
|
he110world/libmeh_working
|
0f324dabdf2dcfc67b18f64acb7d9629aed1c04f
|
|
|
|
|
varying vec3 L, E;
varying vec2 texcoord;
varying vec3 cubecoord;
attribute vec3 tangent;
uniform vec4 light;
void main(void){
gl_Position = ftransform();
texcoord=gl_MultiTexCoord0.xy;
cubecoord=gl_MultiTexCoord1.xyz;
vec3 n = normalize(gl_NormalMatrix*gl_Normal);
vec3 t = normalize(gl_NormalMatrix*tangent);
vec3 b = cross(n,t);
vec3 vert = vec3(gl_ModelViewMatrix * gl_Vertex);
vec3 tmp = vec3(gl_ModelViewMatrix*light)-vert;
// vec3 tmp = light-vert;
// vec3 tmp = light-gl_Vertex.xyz;
L.x = dot(tmp,t);
L.y = dot(tmp,b);
L.z = dot(tmp,n);
tmp = -vert;
E.x = dot(tmp,t);
E.y = dot(tmp,b);
E.z = dot(tmp,n);
}
varying vec3 L,E;
varying vec2 texcoord;
varying vec3 cubecoord;
uniform sampler2D colortex, normaltex;
uniform samplerCube stenciltex;
float appr_pow(float t)
{
return max(0.0, 8.0*t-7.0);
}
void main()
{
float invradius=1.0/100.0;
float distsqr = dot(L,L);
float att = clamp(1.0 - invradius * sqrt(distsqr), 0.0, 1.0);
vec3 newL = L*inversesqrt(distsqr);
vec3 newE = normalize(E);
vec4 color=texture2D(colortex, texcoord);
float opaque=textureCube(stenciltex, cubecoord).a;
vec3 N=normalize(texture2D(normaltex, texcoord).xyz*2.0 - 1.0);
float diffuse = max(dot(N,newL),0.0);
// float spec = pow(clamp(dot(reflect(-newL,N),newE),0.0,1.0), 16.0);
// float spec = clamp(dot(reflect(-newL,N),newE),0.0,1.0);
float spec = dot(reflect(-newL,N),newE);
// vec3 R=normalize(2*N-newL);
// float spec = appr_pow(clamp(dot(N,R),0.0,1.0));
// float spec = pow(clamp(dot(N,R),0.0,1.0),1.0);
// gl_FragColor = att*(vec4(diffuse)*color+vec4(.5*spec));
gl_FragColor = att*(vec4(diffuse+spec)*color);
gl_FragColor.a = opaque;
}
|
|
|
|
|
e723f4d5cf2200b470bfcf636bc1085e063958ba
|
|
|
|
|
jimmywarting/highlight-saas
|
93c18a3da8c0b0e280944c46a4e20928ad800e6e
|
|
|
|
|
|
jimmywarting/highlight-saas
|
93c18a3da8c0b0e280944c46a4e20928ad800e6e
|
|
|
|
|
|
jimmywarting/highlight-saas
|
93c18a3da8c0b0e280944c46a4e20928ad800e6e
|
|
|
|
|
const { highlight, highlightAuto, getLanguage } = require('highlight.js')
const compression = require('compression')
const express = require('express')
const inlineCss = require('inline-css/lib/inline-css')
const cors = require('cors')
const bodyParser = require('express/node_modules/body-parser')
const config = require('./config.json')
const app = express()
const multer = require('multer')
const upload = multer({})
const urlencodedParser = bodyParser.urlencoded({extended: false})
const jsonParser = bodyParser.json()
const textParser = bodyParser.text()
app.disable('x-powered-by')
app.use(compression())
app.use(cors())
const defaultStyle = config.styles['atom-one-dark']
function getDefault(opts) {
let language = (opts.language || 'auto').toLowerCase()
let style = (opts.style || '').toLowerCase()
let content = opts.content || `I'm a teapot`
if (!getLanguage(language)) language = 'auto'
if (!style || !Object.keys(config.styles).includes(style)) style = 'atom-one-dark'
style = config.styles[style]
content = language === 'auto'
? highlightAuto(content).value
: highlight(language, content).value
return { content, style }
}
app.get('/favicon.ico', (_, res) => res.sendStatus(404))
app.all('*', jsonParser, urlencodedParser, textParser, upload.single(), async (req, res) => {
const myOrigin = req.protocol + '://' + req.get('host')
const url = new URL(myOrigin + req.originalUrl)
if (url.pathname === '/' && url.search === '' && req.method === 'GET')
// return res.send(require('fs').readFileSync('./index.html', { encoding: 'utf8' }).toString('ascii'))
return res.send(config.index)
const body = typeof req.body === 'string' ? {content: req.body} : req.body || {}
body.content = body.content || url.searchParams.get('content')
body.style = body.style || url.searchParams.get('style')
body.language = body.language || url.searchParams.get('language')
const def = getDefault(body)
const origin = req.get('origin') || ''
const accept = req.get('accept') || ''
const referrer = req.get('Referrer') || ''
style = def.style
content = def.content
if (referrer && accept.includes('image') && !referrer.includes(myOrigin)) {
content = `<body><pre class="hljs"><code>${content}</code></pre></body>`
content += '<script></script>'
content = inlineCss(content, style + config.extraCss, config.inlineOpts)
} else {
content = `<pre class="hljs"><code>${content}</code></pre>`
content = inlineCss(content, style, config.inlineOpts)
}
res.send(content)
})
app.listen(process.env.PORT || 3000)
|
|
|
|
|
5f5df4c16e3cbba91cabd10a1877c24964949db2
|
|
|
|
src/tests/utilities.test.ts
|
|
4645d891f4825458553b94119a7b5731bed715d3
|
|
|
|
|
src/tests/utilities.test.ts
|
|
4645d891f4825458553b94119a7b5731bed715d3
|
|
|
|
|
src/tests/utilities.test.ts
|
|
4645d891f4825458553b94119a7b5731bed715d3
|
|
|
|
|
import * as utilities from "utilities";
describe("utilities", () => {
describe("quicksort", () => {
const compareItem = (input: number) => {
return input;
};
const numbers: number[] = [];
for (let i = 0; i < 25; i++) numbers.push(Math.random());
it("orders properly", () => {
const sortedNums = utilities.quicksort<number>(numbers, compareItem);
for (let i = 1; i < sortedNums.length; i++)
expect(sortedNums[i - 1]).toBeLessThanOrEqual(sortedNums[i]);
});
});
describe("getNowDateTimeString", () => {
// This tests will fail intermittently if there is a bug with the 0-prepend
it("returns string of correct length", () => {
const expectedLength = "YYYY-MM-DD_hh-mm-ss".length;
expect(utilities.getNowDateTimeString().length).toBe(expectedLength);
});
});
describe("LevenshteinDistance", () => {
let finder: utilities.LevenshteinDistance;
const testParams: utilities.LevenshteinDistParams = {
delCost: 3,
insCost: 4,
subCost: 5,
};
beforeEach(() => {
finder = new utilities.LevenshteinDistance(testParams);
});
describe("getDistance", () => {
const baseWord = "testing";
test("with empty word", () => {
expect(finder.getDistance("", "")).toEqual(0);
expect(finder.getDistance(baseWord, "")).toEqual(
baseWord.length * testParams.delCost
);
expect(finder.getDistance("", baseWord)).toEqual(
baseWord.length * testParams.insCost
);
});
const similarCases: [string, string, number][] = [
["same word", baseWord, 0],
["1 deletion", "testin", testParams.delCost],
["1 insertion", "testings", testParams.insCost],
["1 substitution", "tasting", testParams.subCost],
["2 substitutions", "tossing", 2 * testParams.subCost],
[
"1 insertion, 1 deletion",
"teasing",
testParams.insCost + testParams.delCost,
],
[
"1 insertion, 1 substitution",
"toasting",
testParams.insCost + testParams.subCost,
],
];
test.each(similarCases)(
"with similar word: %p",
(_description: string, secondWord: string, expectedDist: number) => {
expect(finder.getDistance(baseWord, secondWord)).toEqual(
expectedDist
);
}
);
test("with much different words", () => {
const diffWord = "QQQ";
expect(finder.getDistance(diffWord, baseWord)).toEqual(
diffWord.length * testParams.subCost +
(baseWord.length - diffWord.length) * testParams.insCost
);
expect(finder.getDistance(baseWord, diffWord)).toEqual(
diffWord.length * testParams.subCost +
(baseWord.length - diffWord.length) * testParams.delCost
);
});
});
});
});
|
|
|
|
|
dfd7c4d2364f15422ade24e6579947af63f87ec7
|
|
|
|
backend/src/connect.database.ts
|
ExiledNarwal28/gif-3112-project
|
806c697705c13d813a85dd643bd733dbd39af96d
|
|
|
|
|
backend/src/connect.database.ts
|
ExiledNarwal28/gif-3112-project
|
806c697705c13d813a85dd643bd733dbd39af96d
|
|
|
|
|
backend/src/connect.database.ts
|
ExiledNarwal28/gif-3112-project
|
806c697705c13d813a85dd643bd733dbd39af96d
|
|
|
|
|
import mongoose from 'mongoose';
import { logger } from './middlewares/logger';
const mongoURL = process.env.MONGO_URL || '';
const mongoOptions = {
useFindAndModify: false,
useNewUrlParser: true,
useUnifiedTopology: true,
user: process.env.MONGO_USERNAME,
pass: process.env.MONGO_PASSWORD,
};
const db = mongoose.connection;
db.on('connecting', () => logger.info('Connecting to MongoDB...'));
db.on('error', (error) =>
logger.error(`Error in MongoDB connection : ${error}`),
);
db.on('connected', () => logger.info('MongoDB connected!'));
db.once('open', async () => {
logger.info('MongoDB connection opened!');
});
db.on('reconnected', () => logger.info('MongoDB reconnected!'));
db.on('disconnected', () => {
logger.info('MongoDB disconnected!');
retryConnectionAfterTimeout();
});
const MAX_ATTEMPTS = 10;
const FACTOR = 1.5;
const DEFAULT_RETRY_TIMEOUT = 5000;
const DEFAULT_ATTEMPTS = 0;
let retryTimeout = DEFAULT_RETRY_TIMEOUT;
let attempts = DEFAULT_ATTEMPTS;
const retryConnectionAfterTimeout = () => {
if (attempts < MAX_ATTEMPTS) {
logger.info(`Retrying connection in ${retryTimeout / 1000} seconds`);
setTimeout(connectDatabase, retryTimeout);
retryTimeout *= FACTOR;
attempts++;
} else {
logger.info(`Max connection attempts (${MAX_ATTEMPTS}) reached!`);
}
};
export function connectDatabase() {
mongoose
.connect(mongoURL, mongoOptions)
.then(() => {
retryTimeout = DEFAULT_RETRY_TIMEOUT;
attempts = DEFAULT_ATTEMPTS;
})
.catch(() => {
retryConnectionAfterTimeout();
});
}
|
|
|
|
|
c36bc166ac8c5e32810efdfb68416109d184994a
|
|
|
|
|
|
03af5b868f238dd04a10c161038759036daee6ac
|
|
|
|
|
|
|
03af5b868f238dd04a10c161038759036daee6ac
|
|
|
|
|
|
|
03af5b868f238dd04a10c161038759036daee6ac
|
|
|
|
|
package st600
func Fuzz(data []byte) int {
p := ParseBytes(data, ParserOpts{})
var results []int
for p.Next() {
frame := p.Msg()
if frame == nil {
panic("nil frame")
}
if len(frame.Frame) == 0 {
panic("empty raw frame")
}
if frame.ParsingError != nil {
results = append(results, 0)
continue
}
switch frame.Type {
case STTReport:
if frame.STT == nil {
panic("nil STT")
}
case EMGReport:
if frame.EMG == nil {
panic("nil EMG")
}
case EVTReport:
if frame.EVT == nil {
panic("nil EVT")
}
case ALTReport:
if frame.ALT == nil {
panic("nil ALT")
}
case ALVReport:
if frame.ALV == nil {
panic("nil ALV")
}
case UEXReport:
if frame.UEX == nil {
panic("nil UEX")
}
case UnknownMsg:
default:
panic("invalid Type")
}
// good frame
results = append(results, 1)
}
// count results (zeroes and ones)
zeroCount := 0
oneCount := 0
for _, r := range results {
switch r {
case 0:
zeroCount++
case 1:
oneCount++
default:
panic("fuzz programming error")
}
}
switch {
case oneCount == 0:
return 0
case zeroCount == 0 || zeroCount == 1: // at most one error permitted
return 1
default:
return 0
}
}
|
|
|
|
|
a1a6cf56c78ce242de3be9a964be2f1ff6b74f8a
|
|
|
|
|
|
a95a4b96a0c93899e2e6c3f1ef0ce911b118a382
|
|
|
|
|
|
|
a95a4b96a0c93899e2e6c3f1ef0ce911b118a382
|
|
|
|
|
|
|
a95a4b96a0c93899e2e6c3f1ef0ce911b118a382
|
|
|
|
|
package cmd
import (
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/client"
"github.com/docker/go-connections/nat"
"github.com/rmohr/cli/docker"
"github.com/spf13/cobra"
"strconv"
)
const (
PORT_SSH = 2201
PORT_REGISTRY = 5000
PORT_OCP = 8443
PORT_K8S = 6443
PORT_VNC = 5901
PORT_NAME_SSH = "ssh"
PORT_NAME_OCP = "ocp"
PORT_NAME_REGISTRY = "registry"
PORT_NAME_K8S = "k8s"
PORT_NAME_VNC = "vnc"
)
func NewPortCommand() *cobra.Command {
port := &cobra.Command{
Use: "ports",
Short: "ports shows exposed ports of the cluster",
Long: `ports shows exposed ports of the cluster
If no port name is specified, all exposed ports are printed.
If an extra port name is specified, only the exposed port is printed.
Known port names are 'ssh', 'registry', 'ocp' and 'k8s'.
`,
RunE: ports,
Args: func(cmd *cobra.Command, args []string) error {
if len(args) > 1 {
return fmt.Errorf("only one port name can be specified at once")
}
if len(args) == 1 {
switch args[0] {
case PORT_NAME_SSH, PORT_NAME_K8S, PORT_NAME_OCP, PORT_NAME_REGISTRY, PORT_NAME_VNC:
return nil
default:
return fmt.Errorf("unknown port name %s", args[0])
}
}
return nil
},
}
return port
}
func ports(cmd *cobra.Command, args []string) error {
prefix, err := cmd.Flags().GetString("prefix")
if err != nil {
return err
}
cli, err := client.NewEnvClient()
if err != nil {
return err
}
container, err := docker.GetDDNSMasqContainer(cli, prefix)
if err != nil {
return err
}
portName := ""
if len(args) > 0 {
portName = args[0]
}
if portName != "" {
err = nil
switch portName {
case PORT_NAME_SSH:
err = printPort(PORT_SSH, container.Ports)
case PORT_NAME_K8S:
err = printPort(PORT_K8S, container.Ports)
case PORT_NAME_REGISTRY:
err = printPort(PORT_REGISTRY, container.Ports)
case PORT_NAME_OCP:
err = printPort(PORT_OCP, container.Ports)
case PORT_NAME_VNC:
err = printPort(PORT_VNC, container.Ports)
}
if err != nil {
return err
}
} else {
for _, p := range container.Ports {
fmt.Printf("%d/%s -> %s:%d\n", p.PrivatePort, p.Type, p.IP, p.PublicPort)
}
}
return nil
}
func getPort(port uint16, ports []types.Port) (uint16, error) {
for _, p := range ports {
if p.PrivatePort == port {
return p.PublicPort, nil
}
}
return 0, fmt.Errorf("port is not exposed")
}
func printPort(port uint16, ports []types.Port) error {
p, err := getPort(port, ports)
if err != nil {
return err
}
fmt.Println(p)
return nil
}
func tcpPortOrDie(port int) nat.Port {
p, err := nat.NewPort("tcp", strconv.Itoa(port))
if err != nil {
panic(err)
}
return p
}
|
|
|
|
|
bd3a662fb349989868d51eb2243cb72e1eac5b28
|
|
|
|
web-server/sgx-wallet-impl/src/schema/types.rs
|
|
31a6a534c920d58548a8ac5869b3cb918d3b7c11
|
|
|
|
|
web-server/sgx-wallet-impl/src/schema/types.rs
|
|
31a6a534c920d58548a8ac5869b3cb918d3b7c11
|
|
|
|
|
web-server/sgx-wallet-impl/src/schema/types.rs
|
|
31a6a534c920d58548a8ac5869b3cb918d3b7c11
|
|
|
|
|
//! Supporting data types.
use std::boxed::Box;
use std::prelude::v1::String;
use ripple_keypairs::{Algorithm, EntropyArray};
use serde::{Deserialize, Serialize};
pub type Bytes = Box<[u8]>;
/// Nautilus Wallet ID.
pub type WalletId = String;
/// A wallet owner's authenticating PIN.
pub type WalletPin = String;
/// Algorand account seed, as bytes.
pub type AlgorandAccountSeedBytes = [u8; 32];
/// Algorand account address, as bytes.
pub type AlgorandAddressBytes = [u8; 32];
/// Algorand account address, as base32 with checksum.
pub type AlgorandAddressBase32 = String;
/// XRPL key type (signing algorithm).
///
/// Docs: <https://xrpl.org/cryptographic-keys.html#signing-algorithms>
#[derive(Copy, Clone, Eq, PartialEq, Debug)] // core
#[derive(Deserialize, Serialize)] // serde
#[serde(rename_all = "lowercase")]
pub enum XrplKeyType {
Secp256k1,
Ed25519,
}
/// Default to `secp256k1`, like the XRP Ledger.
impl Default for XrplKeyType {
fn default() -> Self {
Self::Secp256k1
}
}
// Convert between our representation and ripple-keypairs.
/// Convert from `&Algorithm`, as used by ripple-keypairs.
impl From<&Algorithm> for XrplKeyType {
fn from(algorithm: &Algorithm) -> Self {
match algorithm {
Algorithm::Secp256k1 => Self::Secp256k1,
Algorithm::Ed25519 => Self::Ed25519,
}
}
}
/// Convert to `&'static Algorithm`, as expected by ripple-keypairs.
impl From<XrplKeyType> for &'static Algorithm {
fn from(key_type: XrplKeyType) -> Self {
match key_type {
XrplKeyType::Secp256k1 => &Algorithm::Secp256k1,
XrplKeyType::Ed25519 => &Algorithm::Ed25519,
}
}
}
/// XRP account seed, as bytes.
pub type XrplAccountSeedBytes = EntropyArray;
/// XRP account address, as base58 with checksum ("Base58Check").
///
/// Docs: <https://xrpl.org/base58-encodings.html>
pub type XrplAddressBase58 = String;
/// XRP public key, as a hexadecimal string. Used to prepare unsigned transactions.
///
/// Docs: <https://xrpl.org/cryptographic-keys.html#public-key>
pub type XrplPublicKeyHex = String;
|
|
|
|
|
653e59fcbdd6ab10a8f9cfbeb5d59f5f53315a37
|
|
|
|
src/trainer/transformations.py
|
tiborkubik/Robust-Teeth-Detection-in-3D-Dental-Scans-by-Automated-Multi-View-Landmarking
|
c7d9fa29b3b94ea786da5f4ec11a11520c1b882a
|
|
|
|
|
src/trainer/transformations.py
|
tiborkubik/Robust-Teeth-Detection-in-3D-Dental-Scans-by-Automated-Multi-View-Landmarking
|
c7d9fa29b3b94ea786da5f4ec11a11520c1b882a
|
|
|
|
|
src/trainer/transformations.py
|
tiborkubik/Robust-Teeth-Detection-in-3D-Dental-Scans-by-Automated-Multi-View-Landmarking
|
c7d9fa29b3b94ea786da5f4ec11a11520c1b882a
|
|
|
|
|
"""
:filename transformations.py
:author Tibor Kubik
:email [email protected]
from
Classes of custom transformations that are applied during the training as additional augmentation of the depth maps.
"""
import torch
import random
import numpy as np
import torch.nn.functional as F
from random import randrange
from skimage.transform import resize, warp, AffineTransform
class Normalize(object):
"""Normalization of a depth map in the value of [0, 1] for each pixel."""
def __init__(self, input_type):
self.input_type = input_type
def __call__(self, sample):
if self.input_type == 'geom':
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
mean, std = image.mean([1, 2]), image.std([1, 2])
# TODO?
return {'image': image,
'landmarks': landmarks,
'label': label}
class ToTensor(object):
"""Transformation of a training sample into a torch tensor instance."""
def __init__(self, input_type):
self.input_type = input_type
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
image = torch.from_numpy(image.copy())
if self.input_type != 'depth+geom':
image = image.unsqueeze(1)
image = image.permute(1, 0, 2)
else:
image = image.permute(2, 0, 1)
landmarks = np.asarray(landmarks)
landmarks = torch.from_numpy(landmarks.copy())
return {'image': image,
'landmarks': landmarks,
'label': label}
class Resize(object):
"""Resizing of the input sample into provided dimensions."""
def __init__(self, width, height, input_type='image'):
assert isinstance(width, int)
assert isinstance(height, int)
self.width = width
self.height = height
self.type = input_type
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
resized_landmarks = landmarks.copy()
if self.type == 'image':
image = resize(image, (self.height, self.width), anti_aliasing=True)
if self.type == 'landmarks':
resized_landmarks = []
for landmark in landmarks:
landmark_resized = resize(landmark, (self.height, self.width), anti_aliasing=True)
resized_landmarks.append(landmark_resized)
return {'image': image,
'landmarks': resized_landmarks,
'label': label}
class RandomTranslating(object):
"""Randomly translate the input sample from range [-10 px, 10 px] with provided probability."""
def __init__(self, p=0.5):
assert isinstance(p, float)
self.p = p
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
translated_landmarks = landmarks.copy()
if np.random.rand(1) < self.p:
n1 = randrange(-10, 10)
n2 = randrange(-10, 10)
t = AffineTransform(translation=(n1, n2))
image = warp(image, t.inverse)
translated_landmarks = []
for landmark in landmarks:
translated_landmarks.append(warp(landmark, t.inverse))
return {'image': image,
'landmarks': translated_landmarks,
'label': label}
class RandomScaling(object):
"""Randomly scales the input sample with scale index from range [0.90, 1.10] with provided probability."""
def __init__(self, p=0.5):
assert isinstance(p, float)
self.p = p
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
scaled_landmarks = landmarks.copy()
if np.random.rand(1) < self.p:
n = random.uniform(0.90, 1.10)
t = AffineTransform(scale=(n, n))
image = warp(image, t.inverse)
scaled_landmarks = []
for landmark in landmarks:
scaled_landmarks.append(warp(landmark, t.inverse))
return {'image': image,
'landmarks': scaled_landmarks,
'label': label}
class RandomRotation(object):
"""Randomly rotates the input sample from range [−11.25 deg, 11.25 deg] with provided probability."""
def __init__(self, p=0.5):
assert isinstance(p, float)
self.p = p
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
rnd_num1 = randrange(-32, -6)
rnd_num2 = randrange(6, 32)
rnd_num = random.choice([rnd_num1, rnd_num2])
if np.random.rand(1) < self.p:
rotated_image = self.rotate(x=image.unsqueeze(0).type(torch.FloatTensor), theta=np.pi/rnd_num)
rotated_landmarks = []
for _, landmark in enumerate(landmarks):
rotated_landmark = self.rotate(x=landmark.unsqueeze(0).unsqueeze(0).type(torch.FloatTensor), theta=np.pi/rnd_num)
rotated_landmarks.append(rotated_landmark.squeeze(0))
result = torch.cat(rotated_landmarks, dim=0)
return {'image': rotated_image.squeeze(0),
'landmarks': result,
'label': label}
return {'image': image,
'landmarks': landmarks,
'label': label}
@staticmethod
def get_rotation_matrix(theta):
"""Returns a tensor rotation matrix with given theta value."""
theta = torch.tensor(theta)
return torch.tensor([[torch.cos(theta), -torch.sin(theta), 0],
[torch.sin(theta), torch.cos(theta), 0]])
def rotate(self, x, theta):
rot_mat = self.get_rotation_matrix(theta)[None, ...].repeat(x.shape[0], 1, 1)
grid = F.affine_grid(rot_mat, x.size(), align_corners=False)
x = F.grid_sample(x, grid, align_corners=False)
return x
|
|
|
|
|
b2c14d3bb32a9d0a97a9d773d034e8784a7e69a4
|
|
|
|
|
|
604136be1c2ef1155bdb7579c7d123525dbe10d8
|
|
|
|
|
|
|
604136be1c2ef1155bdb7579c7d123525dbe10d8
|
|
|
|
|
|
|
604136be1c2ef1155bdb7579c7d123525dbe10d8
|
|
|
|
|
""" Identify low-level jets in wind profile data.
Peter Kalverla
December 2020
"""
import numpy as np
import xarray as xr
def detect_llj(x, axis=None, falloff=0, output='strength', inverse=False):
""" Identify maxima in wind profiles.
args:
- x : ndarray with wind profile data
- axis : specifies the vertical dimension
is internally used with np.apply_along_axis
- falloff : threshold for labeling as low-level jet
default 0; can be masked later, e.g. llj[falloff>2.0]
- output : specifiy return type: 'strength' or 'index'
returns (depending on <output> argument):
- strength : 0 if no maximum identified, otherwise falloff strength
- index : nan if no maximum identified, otherwise index along
<axis>, to get the height of the jet etc.
"""
def inner(x, output):
if inverse:
x = x[::-1, ...]
# Identify local maxima
x = x[~np.isnan(x)]
dx = x[1:] - x[:-1]
ind = np.where((np.hstack((dx, 0)) < 0) & (np.hstack((0, dx)) >= 0))[0]
# Last value of x cannot be llj
if ind.size and ind[-1] == x.size - 1:
ind = ind[:-1]
# Compute the falloff strength for each local maxima
if ind.size: # this assumes height increases along axis!!!
strength = np.array([x[i] - min(x[i:]) for i in ind])
imax = np.argmax(strength)
# Return jet_strength and index of maximum:
if output == 'strength':
r = max(strength) if ind.size else 0
elif output == 'index':
r = ind[imax] if ind.size else 0
return r
# Wrapper interface to apply 1d function to ndarray
return np.apply_along_axis(inner, axis, x, output=output)
def detect_llj_vectorized(xs,
axis=-1,
output='falloff',
mask_inv=False,
inverse=False):
""" Identify local maxima in wind profiles.
args:
- x : ndarray with wind profile data
- axis : specifies the vertical dimension
- output : specifiy return type: 'falloff', 'strength' or 'index'
- mask_inv : use np.ma to mask nan values
returns (depending on <output> argument and whether llj is identified):
- falloff : 0 or largest difference between local max and subseq min
- strength : 0 or wind speed at jet height
- index : -1 or index along <axis>
"""
# Move <axis> to first dimension, to easily index and iterate over it.
xv = np.rollaxis(xs, axis)
if inverse:
xv = xv[::-1, ...]
if mask_inv:
xv = np.ma.masked_invalid(xv)
# Set initial arrays
min_elem = xv[-1].copy()
max_elem = np.zeros(min_elem.shape)
max_diff = np.zeros(min_elem.shape)
max_idx = np.ones(min_elem.shape, dtype=int) * (-1)
# Start at end of array and search backwards for larger differences.
for i, elem in reversed(list(enumerate(xv))):
min_elem = np.minimum(elem, min_elem)
new_max_identified = elem - min_elem > max_diff
max_diff = np.where(new_max_identified, elem - min_elem, max_diff)
max_elem = np.where(new_max_identified, elem, max_elem)
max_idx = np.where(new_max_identified, i, max_idx)
if output == 'falloff':
r = max_diff
elif output == 'strength':
r = max_elem
elif output == 'index':
r = max_idx
else:
raise ValueError('Invalid argument for <output>: %s' % output)
return r
def detect_llj_xarray(da, inverse=False):
""" Identify local maxima in wind profiles.
args:
- da : xarray.DataArray with wind profile data
- inverse : to flip the array if the data is stored upside down
returns: : xarray.Dataset with vertical dimension removed containing:
- falloff : 0 or largest difference between local max and subseq min
- strength : 0 or wind speed at jet height
- index : -1 or index along <axis>
Note: vertical dimension should be labeled 'level' and axis=1
"""
# Move <axis> to first dimension, to easily index and iterate over it.
xv = np.rollaxis(da.values, 1)
if inverse:
xv = xv[::-1, ...]
# Set initial arrays
min_elem = xv[-1].copy()
max_elem = np.zeros(min_elem.shape)
max_diff = np.zeros(min_elem.shape)
max_idx = np.ones(min_elem.shape, dtype=int) * (-1)
# Start at end of array and search backwards for larger differences.
for i, elem in reversed(list(enumerate(xv))):
min_elem = np.minimum(elem, min_elem)
new_max_identified = elem - min_elem > max_diff
max_diff = np.where(new_max_identified, elem - min_elem, max_diff)
max_elem = np.where(new_max_identified, elem, max_elem)
max_idx = np.where(new_max_identified, i, max_idx)
# Combine the results in a dataframe
get_height = lambda i: np.where(i > 0, da.level.values[i], da.level.values[
-1])
dims = da.isel(level=0).drop('level').dims
coords = da.isel(level=0).drop('level').coords
lljs = xr.Dataset(
{
'falloff': (dims, max_diff),
'strength': (dims, max_elem),
'level': (dims, get_height(max_idx)),
},
coords=coords)
print(
'Beware! Level is also filled if no jet is detected! '
'Use ds.sel(level=lljs.level).where(lljs.falloff>0) to get rid of them'
)
return lljs
|
|
|
|
|
08963ea78b7a7c8e6fdbd6c088271a84b9c0754d
|
|
|
|
pkg/langserver/diagnostics.go
|
|
dc37d204598e1ff39ccbbd3bec5ba897486c2df6
|
|
|
|
|
pkg/langserver/diagnostics.go
|
|
dc37d204598e1ff39ccbbd3bec5ba897486c2df6
|
|
|
|
|
pkg/langserver/diagnostics.go
|
|
dc37d204598e1ff39ccbbd3bec5ba897486c2df6
|
|
|
|
|
package langserver
import (
"context"
"log"
"net/url"
"path/filepath"
"strings"
"github.com/dbaumgarten/yodk/pkg/lsp"
"github.com/dbaumgarten/yodk/pkg/nolol"
"github.com/dbaumgarten/yodk/pkg/nolol/nast"
"github.com/dbaumgarten/yodk/pkg/optimizers"
"github.com/dbaumgarten/yodk/pkg/parser"
"github.com/dbaumgarten/yodk/pkg/parser/ast"
"github.com/dbaumgarten/yodk/pkg/validators"
)
// fs is a special filesystem that retrieves the main file from the cache and all
// other files from the filesystem. It is used when compiling a nolol file, as nolol files may
// depend on files from the file-system using includes
type fs struct {
*nolol.DiskFileSystem
ls *LangServer
Mainfile string
}
func getFilePath(u lsp.DocumentURI) string {
ur, _ := url.Parse(string(u))
s := filepath.FromSlash(ur.Path)
if !strings.HasSuffix(s, "\\\\") {
s = strings.TrimPrefix(s, "\\")
}
return s
}
func newfs(ls *LangServer, mainfile lsp.DocumentURI) *fs {
return &fs{
ls: ls,
DiskFileSystem: &nolol.DiskFileSystem{
Dir: filepath.Dir(getFilePath(mainfile)),
},
Mainfile: string(mainfile),
}
}
func (f fs) Get(name string) (string, error) {
if name == f.Mainfile {
return f.ls.cache.Get(lsp.DocumentURI(name))
}
return f.DiskFileSystem.Get(name)
}
func convertToErrorlist(errs error) parser.Errors {
if errs == nil {
return make(parser.Errors, 0)
}
switch e := errs.(type) {
case parser.Errors:
return e
case *parser.Error:
// if it is a single error, convert it to a one-element list
errlist := make(parser.Errors, 1)
errlist[0] = e
return errlist
default:
log.Printf("Unknown error type: %T\n (%s)", errs, errs.Error())
return nil
}
}
func convertErrorsToDiagnostics(errs parser.Errors, source string, severity lsp.DiagnosticSeverity) []lsp.Diagnostic {
diags := make([]lsp.Diagnostic, 0)
for _, err := range errs {
diag := convertErrorToDiagnostic(err, source, severity)
diags = append(diags, diag)
}
return diags
}
func convertErrorToDiagnostic(err *parser.Error, source string, severity lsp.DiagnosticSeverity) lsp.Diagnostic {
return lsp.Diagnostic{
Source: source,
Message: err.Message,
Severity: severity,
Range: lsp.Range{
Start: lsp.Position{
Line: float64(err.StartPosition.Line) - 1,
Character: float64(err.StartPosition.Coloumn) - 1,
},
End: lsp.Position{
Line: float64(err.EndPosition.Line) - 1,
Character: float64(err.EndPosition.Coloumn) - 1,
},
},
}
}
func (s *LangServer) validateCodeLength(uri lsp.DocumentURI, text string, parsed *ast.Program) []lsp.Diagnostic {
// check if the code-length of yolol-code is OK
if s.settings.Yolol.LengthChecking.Mode != LengthCheckModeOff {
lengtherror := validators.ValidateCodeLength(text)
// check if the code is small enough after optimizing it
if lengtherror != nil && s.settings.Yolol.LengthChecking.Mode == LengthCheckModeOptimize && parsed != nil {
opt := optimizers.NewCompoundOptimizer()
err := opt.Optimize(parsed)
if err == nil {
printer := parser.Printer{}
optimized, err := printer.Print(parsed)
if err == nil {
lengtherror = validators.ValidateCodeLength(optimized)
}
}
}
if lengtherror != nil {
err := lengtherror.(*parser.Error)
diag := convertErrorToDiagnostic(err, "validator", lsp.SeverityWarning)
return []lsp.Diagnostic{diag}
}
}
return []lsp.Diagnostic{}
}
func (s *LangServer) validateAvailableOperations(uri lsp.DocumentURI, parsed ast.Node) []lsp.Diagnostic {
chipType, _ := validators.AutoChooseChipType(s.settings.Yolol.ChipType, string(uri))
err := validators.ValidateAvailableOperations(parsed, chipType)
if err != nil {
errors := convertToErrorlist(err)
return convertErrorsToDiagnostics(errors, "validator", lsp.SeverityError)
}
return []lsp.Diagnostic{}
}
func (s *LangServer) Diagnose(ctx context.Context, uri lsp.DocumentURI) {
go func() {
var parserError error
var validationDiagnostics []lsp.Diagnostic
var diagRes DiagnosticResults
text, _ := s.cache.Get(uri)
prevDiag, err := s.cache.GetDiagnostics(uri)
if err == nil {
diagRes = *prevDiag
}
if strings.HasSuffix(string(uri), ".yolol") {
p := parser.NewParser()
var parsed *ast.Program
parsed, parserError = p.Parse(text)
if parsed != nil {
diagRes.Variables = findUsedVariables(parsed)
}
if parserError == nil {
validationDiagnostics = s.validateAvailableOperations(uri, parsed)
validationDiagnostics = append(validationDiagnostics, s.validateCodeLength(uri, text, parsed)...)
}
} else if strings.HasSuffix(string(uri), ".nolol") {
mainfile := string(uri)
converter := nolol.NewConverter()
converter.SetChipType(s.settings.Yolol.ChipType)
included := converter.LoadFileEx(mainfile, newfs(s, uri)).ProcessIncludes()
parserError = included.Error()
if parserError == nil {
intermediate := included.GetIntermediateProgram()
// Analyze() will mutate the ast, so we create a copy of it
analyse := nast.CopyAst(intermediate).(*nast.Program)
analysis, err := nolol.Analyse(analyse)
if err == nil {
diagRes.AnalysisReport = analysis
}
parserError = included.ProcessCodeExpansion().ProcessNodes().ProcessLineNumbers().ProcessFinalize().Error()
}
} else {
return
}
s.cache.SetDiagnostics(uri, diagRes)
parserErrors := convertToErrorlist(parserError)
if parserErrors == nil {
return
}
diags := convertErrorsToDiagnostics(parserErrors, "parser", lsp.SeverityError)
if validationDiagnostics != nil {
diags = append(diags, validationDiagnostics...)
}
s.client.PublishDiagnostics(ctx, &lsp.PublishDiagnosticsParams{
URI: uri,
Diagnostics: diags,
})
}()
}
|
|
|
|
|
62725e36e9c4383385bbd866c1009e735beeb419
|
|
|
|
lexical-core/src/itoa/naive.rs
|
ignatenkobrain/rust-lexical
|
fefe81850e5678450ec0f001f562b182694caadf
|
|
|
|
|
lexical-core/src/itoa/naive.rs
|
ignatenkobrain/rust-lexical
|
fefe81850e5678450ec0f001f562b182694caadf
|
|
|
|
|
lexical-core/src/itoa/naive.rs
|
ignatenkobrain/rust-lexical
|
fefe81850e5678450ec0f001f562b182694caadf
|
|
|
|
|
//! Slow, simple lexical integer-to-string conversion routine.
use util::*;
// Naive itoa algorithm.
macro_rules! naive_algorithm {
($value:ident, $radix:ident, $buffer:ident, $index:ident) => ({
while $value >= $radix {
let r = ($value % $radix).as_usize();
$value /= $radix;
// This is always safe, since r must be [0, radix).
$index -= 1;
unchecked_index_mut!($buffer[$index] = digit_to_char(r));
}
// Decode last digit.
let r = ($value % $radix).as_usize();
// This is always safe, since r must be [0, radix).
$index -= 1;
unchecked_index_mut!($buffer[$index] = digit_to_char(r));
});
}
// Naive implementation for radix-N numbers.
// Precondition: `value` must be non-negative and mutable.
perftools_inline!{
fn naive<T>(mut value: T, radix: u32, buffer: &mut [u8])
-> usize
where T: UnsignedInteger
{
// Decode all but last digit, 1 at a time.
let mut index = buffer.len();
let radix: T = as_cast(radix);
naive_algorithm!(value, radix, buffer, index);
index
}}
pub(crate) trait Naive {
// Export integer to string.
fn naive(self, radix: u32, buffer: &mut [u8]) -> usize;
}
// Implement naive for type.
macro_rules! naive_impl {
($($t:ty)*) => ($(
impl Naive for $t {
perftools_inline_always!{
fn naive(self, radix: u32, buffer: &mut [u8]) -> usize {
naive(self, radix, buffer)
}}
}
)*);
}
naive_impl! { u8 u16 u32 u64 usize }
// Naive implementation for 128-bit radix-N numbers.
// Precondition: `value` must be non-negative and mutable.
perftools_inline!{
#[cfg(has_i128)]
fn naive_u128(value: u128, radix: u32, buffer: &mut [u8])
-> usize
{
// Decode all but last digit, 1 at a time.
let (divisor, digits_per_iter, d_cltz) = u128_divisor(radix);
let radix: u64 = as_cast(radix);
// To deal with internal 0 values or values with internal 0 digits set,
// we store the starting index, and if not all digits are written,
// we just skip down `digits` digits for the next value.
let mut index = buffer.len();
let mut start_index = index;
let (value, mut low) = u128_divrem(value, divisor, d_cltz);
naive_algorithm!(low, radix, buffer, index);
if value != 0 {
start_index -= digits_per_iter;
index = index.min(start_index);
let (value, mut mid) = u128_divrem(value, divisor, d_cltz);
naive_algorithm!(mid, radix, buffer, index);
if value != 0 {
start_index -= digits_per_iter;
index = index.min(start_index);
let mut high = value as u64;
naive_algorithm!(high, radix, buffer, index);
}
}
index
}}
#[cfg(has_i128)]
impl Naive for u128 {
perftools_inline_always!{
fn naive(self, radix: u32, buffer: &mut [u8]) -> usize {
naive_u128(self, radix, buffer)
}}
}
|
|
|
|
|
330e71b3b4bc8bea5b484ce2931ef4411a75120b
|
|
|
|
|
rzepinskip/optimization-svm
|
9682980e19d5fc9f09353aa1284e86874e954aec
|
|
|
|
|
|
rzepinskip/optimization-svm
|
9682980e19d5fc9f09353aa1284e86874e954aec
|
|
|
|
|
|
rzepinskip/optimization-svm
|
9682980e19d5fc9f09353aa1284e86874e954aec
|
|
|
|
|
import numpy as np
from matplotlib import pyplot as plt
from optsvm.svm import SVM
x_neg = np.array([[3, 4], [1, 4], [2, 3]])
y_neg = np.array([-1, -1, -1])
x_pos = np.array([[6, -1], [7, -1], [5, -3]])
y_pos = np.array([1, 1, 1])
x1 = np.linspace(-10, 10)
x = np.vstack((np.linspace(-10, 10), np.linspace(-10, 10)))
# Data for the next section
X = np.vstack((x_neg, x_pos))
y = np.concatenate((y_neg, y_pos))
# Plot
fig = plt.figure(figsize=(10, 10))
plt.scatter(x_neg[:, 0], x_neg[:, 1], marker="x", color="r", label="Negative -1")
plt.scatter(x_pos[:, 0], x_pos[:, 1], marker="o", color="b", label="Positive +1")
plt.plot(x1, x1 - 3, color="darkblue")
plt.plot(x1, x1 - 7, linestyle="--", alpha=0.3, color="b")
plt.plot(x1, x1 + 1, linestyle="--", alpha=0.3, color="r")
plt.xlim(-2, 12)
plt.ylim(-7, 7)
plt.xticks(np.arange(0, 10, step=1))
plt.yticks(np.arange(-5, 5, step=1))
# Lines
plt.axvline(0, color="black", alpha=0.5)
plt.axhline(0, color="black", alpha=0.5)
plt.plot([2, 6], [3, -1], linestyle="-", color="darkblue", alpha=0.5)
plt.plot([4, 6], [1, 1], [6, 6], [1, -1], linestyle=":", color="darkblue", alpha=0.5)
plt.plot(
[0, 1.5], [0, -1.5], [6, 6], [1, -1], linestyle=":", color="darkblue", alpha=0.5
)
# Annotations
plt.annotate(s="$A \ (6,-1)$", xy=(5, -1), xytext=(6, -1.5))
plt.annotate(
s="$B \ (2,3)$", xy=(2, 3), xytext=(2, 3.5)
) # , arrowprops = {'width':.2, 'headwidth':8})
plt.annotate(s="$2$", xy=(5, 1.2), xytext=(5, 1.2))
plt.annotate(s="$2$", xy=(6.2, 0.5), xytext=(6.2, 0.5))
plt.annotate(s="$2\sqrt{2}$", xy=(4.5, -0.5), xytext=(4.5, -0.5))
plt.annotate(s="$2\sqrt{2}$", xy=(2.5, 1.5), xytext=(2.5, 1.5))
plt.annotate(s="$w^Tx + b = 0$", xy=(8, 4.5), xytext=(8, 4.5))
plt.annotate(
s="$(\\frac{1}{4},-\\frac{1}{4}) \\binom{x_1}{x_2}- \\frac{3}{4} = 0$",
xy=(7.5, 4),
xytext=(7.5, 4),
)
plt.annotate(s="$\\frac{3}{\sqrt{2}}$", xy=(0.5, -1), xytext=(0.5, -1))
# Labels and show
plt.xlabel("$x_1$")
plt.ylabel("$x_2$")
plt.legend(loc="lower right")
plt.show()
svm = SVM(C=10)
svm.fit(X, y)
# Display results
print("---Our results")
print("w = ", svm.w_.flatten())
print("b = ", svm.b_)
from sklearn.svm import SVC
clf = SVC(C=10, kernel="linear")
clf.fit(X, y.ravel())
print("---SVM library")
print("w = ", clf.coef_)
print("b = ", clf.intercept_)
|
|
|
|
|
aef7e7c2a975620456846d7b4b268a42a96b390e
|
|
|
|
|
|
942388ac518b6890063e8158c7f5eb52712a67f2
|
[
"PostgreSQL",
"Unlicense",
"MIT"
] |
|
|
|
|
|
942388ac518b6890063e8158c7f5eb52712a67f2
|
[
"PostgreSQL",
"Unlicense",
"MIT"
] |
|
|
|
|
|
942388ac518b6890063e8158c7f5eb52712a67f2
|
[
"PostgreSQL",
"Unlicense",
"MIT"
] |
|
|
|
do $$
local testfunc = function () error("my error") end
local f = function()
local status, err = pcall(testfunc)
if (err) then
error(err)
end
end
f()
$$language pllua;
create or replace function pg_temp.function_with_error() returns integer as $$
local testfunc = function () error("my error") end
local f = function()
local status, err = pcall(testfunc)
if (err) then
error(err)
end
end
f()
$$language plluau;
create or replace function pg_temp.second_function() returns void as $$
local k = server.execute('select pg_temp.function_with_error()') [0]
$$language plluau;
do $$
server.execute('select pg_temp.second_function()')
$$language pllua;
do $$
local status, err = subtransaction(function() assert(1==2) end)
if (err) then
error(err)
end
$$language pllua;
do $$
info({message="info message", hint="info hint", detail="info detail"})
$$language pllua;
do $$
info("info message")
$$language pllua;
do $$
warning({message="warning message", hint="warning hint", detail="warning detail"})
$$language pllua;
do $$
warning("warning message")
$$language pllua;
do $$
error({message="error message", hint="error hint", detail="error detail"})
$$language pllua;
do $$
error("error message")
$$language pllua;
do $$
info()
$$language pllua;
do $$
warning()
$$language pllua;
do $$
error()
$$language pllua;
do $$
local status, err = subtransaction(function() local _ = fromstring('no_type_text','qwerty') end)
if (err) then
print(err)
end
$$ language pllua
|
|
|
|
|
6364a84db8d9c16cc598090ab621288ec02090e2
|
|
|
|
snakebroadcast/src/main/java/com/uiza/sdkbroadcast/helpers/ICameraHelper.kt
|
|
681adca006f61e38151cf73cf711a951f05c57dc
|
|
|
|
|
snakebroadcast/src/main/java/com/uiza/sdkbroadcast/helpers/ICameraHelper.kt
|
|
681adca006f61e38151cf73cf711a951f05c57dc
|
|
|
|
|
snakebroadcast/src/main/java/com/uiza/sdkbroadcast/helpers/ICameraHelper.kt
|
|
681adca006f61e38151cf73cf711a951f05c57dc
|
|
|
|
|
package com.uiza.sdkbroadcast.helpers
import android.content.Context
import android.view.MotionEvent
import com.pedro.encoder.input.gl.render.filters.BaseFilterRender
import com.pedro.encoder.input.video.CameraHelper.Facing
import com.pedro.rtplibrary.view.OpenGlView
import com.uiza.sdkbroadcast.interfaces.UZCameraChangeListener
import com.uiza.sdkbroadcast.interfaces.UZCameraOpenException
import com.uiza.sdkbroadcast.interfaces.UZRecordListener
import com.uiza.sdkbroadcast.interfaces.UZTakePhotoCallback
import com.uiza.sdkbroadcast.profile.AudioAttributes
import com.uiza.sdkbroadcast.profile.VideoAttributes
import com.uiza.sdkbroadcast.profile.VideoSize
import java.io.IOException
interface ICameraHelper {
val mOpenGlView: OpenGlView?
/**
* @param reTries retry connect reTries times
*/
fun setConnectReTries(reTries: Int)
fun setUZCameraChangeListener(uzCameraChangeListener: UZCameraChangeListener?)
fun setUZRecordListener(uzRecordListener: UZRecordListener?)
fun replaceView(openGlView: OpenGlView?)
fun replaceView(context: Context?)
fun setVideoAttributes(attributes: VideoAttributes?)
fun setAudioAttributes(attributes: AudioAttributes?)
fun setLandscape(landscape: Boolean)
/**
* Set filter in position 0.
*
* @param filterReader filter to set. You can modify parameters to filter after set it to stream.
*/
fun setFilter(filterReader: BaseFilterRender?)
/**
* @param filterPosition position of filter
* @param filterReader filter to set. You can modify parameters to filter after set it to stream.
*/
fun setFilter(filterPosition: Int, filterReader: BaseFilterRender?)
/**
* Get Anti alias is enabled.
*
* @return true is enabled, false is disabled.
*/
val isAAEnabled: Boolean
/**
* Enable or disable Anti aliasing (This method use FXAA).
*
* @param aAEnabled true is AA enabled, false is AA disabled. False by default.
*/
fun enableAA(aAEnabled: Boolean)
/**
* get Stream Width
*/
val streamWidth: Int
/**
* get Stream Height
*/
val streamHeight: Int
/**
* Enable a muted microphone, can be called before, while and after broadcast.
*/
fun enableAudio()
/**
* Mute microphone, can be called before, while and after broadcast.
*/
fun disableAudio()
/**
* Get mute state of microphone.
*
* @return true if muted, false if enabled
*/
val isAudioMuted: Boolean
/**
* You will do a portrait broadcast
*
* @return true if success, false if you get a error (Normally because the encoder selected
* doesn't support any configuration seated or your device hasn't a H264 encoder).
*/
fun prepareBroadCast(): Boolean
/**
* @param isLandscape boolean
* @return true if success, false if you get a error (Normally because the encoder selected
* doesn't support any configuration seated or your device hasn't a H264 encoder).
*/
fun prepareBroadCast(isLandscape: Boolean): Boolean
/**
* Call this method before use [.startBroadCast].
*
* @param audioAttributes [AudioAttributes] If null you will do a broadcast without audio.
* @param videoAttributes [VideoAttributes]
* @param isLandscape boolean you will broadcast is landscape
* @return true if success, false if you get a error (Normally because the encoder selected
* doesn't support any configuration seated or your device hasn't a AAC encoder).
*/
fun prepareBroadCast(
audioAttributes: AudioAttributes?,
videoAttributes: VideoAttributes,
isLandscape: Boolean
): Boolean
/**
* Get video camera state
*
* @return true if disabled, false if enabled
*/
val isVideoEnabled: Boolean
/**
* Need be called after [.prepareBroadCast] or/and [.prepareBroadCast].
*
* @param broadCastUrl of the broadcast like: rtmp://ip:port/application/stream_name
*
*
* RTMP: rtmp://192.168.1.1:1935/fmp4/live_stream_name
* [.startPreview] to resolution seated in
* [.prepareBroadCast].
* If you never startPreview this method [.startPreview] for you to resolution seated in
* [.prepareBroadCast].
*/
fun startBroadCast(broadCastUrl: String?)
/**
* Stop BroadCast started with [.startBroadCast]
*/
fun stopBroadCast()
/**
* Get broadcast state.
*
* @return true if broadcasting, false if not broadcasting.
*/
val isBroadCasting: Boolean
/**
* @return list of [VideoSize]
*/
val supportedResolutions: List<VideoSize?>?
/**
* Switch camera used. Can be called on preview or while stream, ignored with preview off.
*
* @throws UZCameraOpenException If the other camera doesn't support same resolution.
*/
@Throws(UZCameraOpenException::class)
fun switchCamera()
/**
* Start camera preview. Ignored, if stream or preview is started.
* resolution of preview 640x480
*
* @param cameraFacing front or back camera. Like: [com.pedro.encoder.input.video.CameraHelper.Facing.BACK]
* [com.pedro.encoder.input.video.CameraHelper.Facing.FRONT]
*/
fun startPreview(cameraFacing: Facing?)
/**
* Start camera preview. Ignored, if stream or preview is started.
*
* @param cameraFacing front or back camera. Like: [com.pedro.encoder.input.video.CameraHelper.Facing.BACK]
* [com.pedro.encoder.input.video.CameraHelper.Facing.FRONT]
* @param width of preview in px.
* @param height of preview in px.
*/
fun startPreview(cameraFacing: Facing?, width: Int, height: Int)
/**
* is Front Camera
*/
val isFrontCamera: Boolean
/**
* check is on preview
*
* @return true if onpreview, false if not preview.
*/
val isOnPreview: Boolean
/**
* Stop camera preview. Ignored if streaming or already stopped. You need call it after
*
* stopStream to release camera properly if you will close activity.
*/
fun stopPreview()
/**
* Get record state.
*
* @return true if recording, false if not recoding.
*/
val isRecording: Boolean
/**
* Start record a MP4 video. Need be called while stream.
*
* @param savePath where file will be saved.
* @throws IOException If you init it before start stream.
*/
@Throws(IOException::class)
fun startRecord(savePath: String?)
/**
* Stop record MP4 video started with @startRecord. If you don't call it file will be unreadable.
*/
fun stopRecord()
/**
* take a photo
*
* @param callback [UZTakePhotoCallback]
*/
fun takePhoto(callback: UZTakePhotoCallback?)
/**
* Set video bitrate of H264 in kb while stream.
*
* @param bitrate H264 in kb.
*/
fun setVideoBitrateOnFly(bitrate: Int)
/**
* @return bitrate in kps
*/
val bitrate: Int
fun reTry(delay: Long, reason: String?): Boolean
/**
* Check support Flashlight
* if use Camera1 always return false
*
* @return true if support, false if not support.
*/
val isLanternSupported: Boolean
/**
* required: <uses-permission android:name="android.permission.FLASHLIGHT"></uses-permission>
*/
@Throws(Exception::class)
fun enableLantern()
/**
* required: <uses-permission android:name="android.permission.FLASHLIGHT"></uses-permission>
*/
fun disableLantern()
val isLanternEnabled: Boolean
/**
* Return max zoom level
*
* @return max zoom level
*/
val maxZoom: Float
/**
* Return current zoom level
*
* @return current zoom level
*/
/**
* Set zoomIn or zoomOut to camera.
* Use this method if you use a zoom slider.
*
* @param level Expected to be >= 1 and <= max zoom level
* @see Camera2Base.getMaxZoom
*/
var zoom: Float
/**
* Set zoomIn or zoomOut to camera.
*
* @param event motion event. Expected to get event.getPointerCount() > 1
*/
fun setZoom(event: MotionEvent?)
}
|
|
|
|
|
f14ffd020b17c8f1a5a89a1bc7cc4ba4f22a988b
|
|
|
|
|
|
f9b2fc999d4c620007462ee7b4bbe71beaf45de6
|
|
|
|
|
|
|
f9b2fc999d4c620007462ee7b4bbe71beaf45de6
|
|
|
|
|
|
|
f9b2fc999d4c620007462ee7b4bbe71beaf45de6
|
|
|
|
|
RUBY_ENGINE = 'unknown' unless defined? RUBY_ENGINE
require 'strscan'
require 'set'
$:.unshift(File.dirname(__FILE__))
# Public: Methods for parsing Asciidoc input files and rendering documents
# using eRuby templates.
#
# Asciidoc documents comprise a header followed by zero or more sections.
# Sections are composed of blocks of content. For example:
#
# = Doc Title
#
# == Section 1
#
# This is a paragraph block in the first section.
#
# == Section 2
#
# This section has a paragraph block and an olist block.
#
# . Item 1
# . Item 2
#
# Examples:
#
# Use built-in templates:
#
# lines = File.readlines("your_file.asc")
# doc = Asciidoctor::Document.new(lines)
# html = doc.render
# File.open("your_file.html", "w+") do |file|
# file.puts html
# end
#
# Use custom (Tilt-supported) templates:
#
# lines = File.readlines("your_file.asc")
# doc = Asciidoctor::Document.new(lines, :template_dir => 'templates')
# html = doc.render
# File.open("your_file.html", "w+") do |file|
# file.puts html
# end
module Asciidoctor
module SafeMode
# A safe mode level that disables any of the security features enforced
# by Asciidoctor (Ruby is still subject to its own restrictions).
UNSAFE = 0;
# A safe mode level that closely parallels safe mode in AsciiDoc. This value
# prevents access to files which reside outside of the parent directory of
# the source file and disables any macro other than the include::[] macro.
SAFE = 1;
# A safe mode level that disallows the document from setting attributes
# that would affect the rendering of the document, in addition to all the
# security features of SafeMode::SAFE. For instance, this level disallows
# changing the backend or the source-highlighter using an attribute defined
# in the source document. This is the most fundamental level of security
# for server-side deployments (hence the name).
SERVER = 10;
# A safe mode level that disallows the document from attempting to read
# files from the file system and including the contents of them into the
# document, in additional to all the security features of SafeMode::SERVER.
# For instance, this level disallows use of the include::[] macro and the
# embedding of binary content (data uri), stylesheets and JavaScripts
# referenced by the document.(Asciidoctor and trusted extensions may still
# be allowed to embed trusted content into the document).
#
# Since Asciidoctor is aiming for wide adoption, this level is the default
# and is recommended for server-side deployments.
SECURE = 20;
# A planned safe mode level that disallows the use of passthrough macros and
# prevents the document from setting any known attributes, in addition to all
# the security features of SafeMode::SECURE.
#
# Please note that this level is not currently implemented (and therefore not
# enforced)!
#PARANOID = 100;
end
# Flags to control compliance with the behavior of AsciiDoc
module Compliance
# AsciiDoc supports both single-line and underlined
# section titles.
# This option disables the underlined variant.
# Compliance value: true
@underline_style_section_titles = true
class << self
attr_accessor :underline_style_section_titles
end
# Asciidoctor will recognize commonly-used Markdown syntax
# to the degree it does not interfere with existing
# AsciiDoc syntax and behavior.
# Compliance value: false
@markdown_syntax = true
class << self
attr_accessor :markdown_syntax
end
end
# The root path of the Asciidoctor gem
ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..'))
# Flag to indicate whether encoding of external strings needs to be forced to UTF-8
# _All_ input data must be force encoded to UTF-8 if Encoding.default_external is *not* UTF-8
# Address failures performing string operations that are reported as "invalid byte sequence in US-ASCII"
# Ruby 1.8 doesn't seem to experience this problem (perhaps because it isn't validating the encodings)
FORCE_ENCODING = RUBY_VERSION > '1.9' && Encoding.default_external != Encoding::UTF_8
# Flag to indicate that line length should be calculated using a unicode mode hint
FORCE_UNICODE_LINE_LENGTH = RUBY_VERSION < '1.9'
# The endline character to use when rendering output
EOL = "\n"
# The default document type
# Can influence markup generated by render templates
DEFAULT_DOCTYPE = 'article'
# The backend determines the format of the rendered output, default to htmlbook (for ORM)
DEFAULT_BACKEND = 'htmlbook'
DEFAULT_STYLESHEET_KEYS = ['', 'DEFAULT'].to_set
DEFAULT_STYLESHEET_NAME = 'asciidoctor.css'
# Pointers to the preferred version for a given backend.
BACKEND_ALIASES = {
'html' => 'html5',
'docbook' => 'docbook45',
'htmlbook' => 'htmlbook'
}
# Default page widths for calculating absolute widths
DEFAULT_PAGE_WIDTHS = {
'docbook' => 425
}
# Default extensions for the respective base backends
DEFAULT_EXTENSIONS = {
'html' => '.html',
'htmlbook' => '.html',
'docbook' => '.xml',
'asciidoc' => '.ad',
'markdown' => '.md'
}
# Set of file extensions recognized as AsciiDoc documents (stored as a truth hash)
ASCIIDOC_EXTENSIONS = {
'.asciidoc' => true,
'.adoc' => true,
'.ad' => true,
'.asc' => true,
'.txt' => true
}
SECTION_LEVELS = {
'=' => 0,
'-' => 1,
'~' => 2,
'^' => 3,
'+' => 4
}
ADMONITION_STYLES = ['NOTE', 'TIP', 'IMPORTANT', 'WARNING', 'CAUTION'].to_set
PARAGRAPH_STYLES = ['comment', 'example', 'literal', 'listing', 'normal', 'pass', 'quote', 'sidebar', 'source', 'verse', 'abstract', 'partintro'].to_set
VERBATIM_STYLES = ['literal', 'listing', 'source', 'verse'].to_set
DELIMITED_BLOCKS = {
'--' => [:open, ['comment', 'example', 'literal', 'listing', 'pass', 'quote', 'sidebar', 'source', 'verse', 'admonition', 'abstract', 'partintro'].to_set],
'----' => [:listing, ['literal', 'source'].to_set],
'....' => [:literal, ['listing', 'source'].to_set],
'====' => [:example, ['admonition'].to_set],
'****' => [:sidebar, Set.new],
'____' => [:quote, ['verse'].to_set],
'""' => [:quote, ['verse'].to_set],
'++++' => [:pass, Set.new],
'|===' => [:table, Set.new],
',===' => [:table, Set.new],
':===' => [:table, Set.new],
'!===' => [:table, Set.new],
'////' => [:comment, Set.new],
'```' => [:fenced_code, Set.new],
'~~~' => [:fenced_code, Set.new]
}
DELIMITED_BLOCK_LEADERS = DELIMITED_BLOCKS.keys.map {|key| key[0..1] }.to_set
BREAK_LINES = {
'\'' => :ruler,
'-' => :ruler,
'*' => :ruler,
'_' => :ruler,
'<' => :page_break
}
#LIST_CONTEXTS = [:ulist, :olist, :dlist, :colist]
NESTABLE_LIST_CONTEXTS = [:ulist, :olist, :dlist]
# TODO validate use of explicit style name above ordered list (this list is for selecting an implicit style)
ORDERED_LIST_STYLES = [:arabic, :loweralpha, :lowerroman, :upperalpha, :upperroman] #, :lowergreek]
ORDERED_LIST_MARKER_PATTERNS = {
:arabic => /\d+[.>]/,
:loweralpha => /[a-z]\./,
:lowerroman => /[ivx]+\)/,
:upperalpha => /[A-Z]\./,
:upperroman => /[IVX]+\)/
#:lowergreek => /[a-z]\]/
}
ORDERED_LIST_KEYWORDS = {
'loweralpha' => 'a',
'lowerroman' => 'i',
'upperalpha' => 'A',
'upperroman' => 'I'
#'lowergreek' => 'a'
#'arabic' => '1'
#'decimal' => '1'
}
LIST_CONTINUATION = '+'
LINE_BREAK = ' +'
# attributes which be changed within the content of the document (but not
# header) because it has semantic meaning; ex. numbered
FLEXIBLE_ATTRIBUTES = %w(numbered)
# NOTE allows for empty space in line as it could be left by the template engine
BLANK_LINE_PATTERN = /^[[:blank:]]*\n/
LINE_FEED_ENTITY = ' ' # or 

# Flags to control compliance with the behavior of AsciiDoc
COMPLIANCE = {
# AsciiDoc terminates paragraphs adjacent to
# block content (delimiter or block attribute list)
# Compliance value: true
# TODO what about literal paragraph?
:block_terminates_paragraph => true,
# AsciiDoc does not treat paragraphs labeled with a
# verbatim style (literal, listing, source, verse)
# as verbatim; override this behavior
# Compliance value: false
:strict_verbatim_paragraphs => true,
# AsciiDoc allows start and end delimiters around
# a block to be different lengths
# this option requires that they be the same
# Compliance value: false
:congruent_block_delimiters => true,
# AsciiDoc drops lines that contain references to missing attributes.
# This behavior is not intuitive to most writers
# Compliance value: 'drop-line'
:attribute_missing => 'skip',
# AsciiDoc drops lines that contain an attribute unassignemnt.
# This behavior may need to be tuned depending on the circumstances.
# Compliance value: 'drop-line'
:attribute_undefined => 'drop-line',
}
# The following pattern, which appears frequently, captures the contents between square brackets,
# ignoring escaped closing brackets (closing brackets prefixed with a backslash '\' character)
#
# Pattern:
# (?:\[((?:\\\]|[^\]])*?)\])
# Matches:
# [enclosed text here] or [enclosed [text\] here]
REGEXP = {
# NOTE: this is a inline admonition note
:admonition_inline => /^(#{ADMONITION_STYLES.to_a * '|'}):\s/,
# [[Foo]]
:anchor => /^\[\[([^\s\[\]]+)\]\]$/,
# Foowhatevs [[Bar]]
:anchor_embedded => /^(.*?)\s*\[\[([^\[\]]+)\]\]$/,
# [[ref]] (anywhere inline)
:anchor_macro => /\\?\[\[([\w":].*?)\]\]/,
# matches any unbounded block delimiter:
# listing, literal, example, sidebar, quote, passthrough, table, fenced code
# does not include open block or air quotes
# TIP position the most common blocks towards the front of the pattern
:any_blk => %r{^(?:(?:-|\.|=|\*|_|\+|/){4,}|[\|,;!]={3,}|(?:`|~){3,}.*)$},
# detect a list item of any sort
# [[:graph:]] is a non-blank character
:any_list => /^(?:
<?\d+>[[:blank:]]+[[:graph:]]|
[[:blank:]]*(?:-|(?:\*|\.){1,5}|\d+\.|[A-Za-z]\.|[IVXivx]+\))[[:blank:]]+[[:graph:]]|
[[:blank:]]*.*?(?::{2,4}|;;)(?:[[:blank:]]+[[:graph:]]|$)
)/x,
# :foo: bar
# :Author: Dan
# :numbered!:
# :long-entry: Attribute value lines ending in ' +'
# are joined together as a single value,
# collapsing the line breaks and indentation to
# a single space.
:attr_entry => /^:(!?\w.*?):(?:[[:blank:]]+(.*))?$/,
# An attribute list above a block element
#
# Can be strictly positional:
# [quote, Adam Smith, Wealth of Nations]
# Or can have name/value pairs
# [NOTE, caption="Good to know"]
# Can be defined by an attribute
# [{lead}]
:blk_attr_list => /^\[(|[[:blank:]]*[\w\{,.#"'%].*)\]$/,
# block attribute list or block id (bulk query)
:attr_line => /^\[(|[[:blank:]]*[\w\{,.#"'%].*|\[[^\[\]]*\])\]$/,
# attribute reference
# {foo}
# {counter:pcount:1}
# {set:foo:bar}
# {set:name!}
:attr_ref => /(\\)?\{((set|counter2?):.+?|\w+(?:[\-]\w+)*)(\\)?\}/,
# The author info line the appears immediately following the document title
# John Doe <[email protected]>
:author_info => /^(\w[\w\-'.]*)(?: +(\w[\w\-'.]*))?(?: +(\w[\w\-'.]*))?(?: +<([^>]+)>)?$/,
# [[[Foo]]] (anywhere inline)
:biblio_macro => /\\?\[\[\[([\w:][\w:.-]*?)\]\]\]/,
# callout reference inside literal text
# <1> (optionally prefixed by //, # or ;; line comment chars)
# <1> <2> (multiple callouts on one line)
# <!--1--> (for XML-based languages)
# special characters are already be replaced at this point during render
:callout_render => /(?:(?:\/\/|#|;;) ?)?(\\)?<!?(--|)(\d+)\2>(?=(?: ?\\?<!?\2\d+\2>)*$)/,
# ...but not while scanning
:callout_quick_scan => /\\?<!?(--|)(\d+)\1>(?=(?: ?\\?<!?\1\d+\1>)*$)/,
:callout_scan => /(?:(?:\/\/|#|;;) ?)?(\\)?<!?(--|)(\d+)\2>(?=(?: ?\\?<!?\2\d+\2>)*$)/,
# <1> Foo
:colist => /^<?(\d+)>[[:blank:]]+(.*)/,
# ////
# comment block
# ////
:comment_blk => %r{^/{4,}$},
# // (and then whatever)
:comment => %r{^//(?:[^/]|$)},
# one,two;three;four
:ssv_or_csv_delim => /,|;/,
# one two three
:space_delim => /([^\\])[[:blank:]]+/,
# Ctrl + Alt+T
# Ctrl,T
:kbd_delim => /(?:\+|,)(?=[[:blank:]]*[^\1])/,
# one\ two\ three
:escaped_space => /\\([[:blank:]])/,
# 29
:digits => /^\d+$/,
# foo:: || foo::: || foo:::: || foo;;
# Should be followed by a definition, on the same line...
# foo:: That which precedes 'bar' (see also, <<bar>>)
# ...or on a separate line
# foo::
# That which precedes 'bar' (see also, <<bar>>)
# The term may be an attribute reference
# {term_foo}:: {def_foo}
# NOTE negative match for comment line is intentional since that isn't handled when looking for next list item
# QUESTION should we check for line comment in regex or when scanning the lines?
:dlist => /^(?!\/\/)[[:blank:]]*(.*?)(:{2,4}|;;)(?:[[:blank:]]+(.*))?$/,
:dlist_siblings => {
# (?:.*?[^:])? - a non-capturing group which grabs longest sequence of characters that doesn't end w/ colon
'::' => /^(?!\/\/)[[:blank:]]*((?:.*[^:])?)(::)(?:[[:blank:]]+(.*))?$/,
':::' => /^(?!\/\/)[[:blank:]]*((?:.*[^:])?)(:::)(?:[[:blank:]]+(.*))?$/,
'::::' => /^(?!\/\/)[[:blank:]]*((?:.*[^:])?)(::::)(?:[[:blank:]]+(.*))?$/,
';;' => /^(?!\/\/)[[:blank:]]*(.*)(;;)(?:[[:blank:]]+(.*))?$/
},
:illegal_sectid_chars => /&(?:[[:alpha:]]+|#[[:digit:]]+|#x[[:alnum:]]+);|\W+?/,
# footnote:[text]
# footnoteref:[id,text]
# footnoteref:[id]
:footnote_macro => /\\?(footnote|footnoteref):\[((?:\\\]|[^\]])*?)\]/,
# gist::123456[]
:generic_blk_macro => /^(\w[\w\-]*)::(\S+?)\[((?:\\\]|[^\]])*?)\]$/,
# kbd:[F3]
# kbd:[Ctrl+Shift+T]
# kbd:[Ctrl+\]]
# kbd:[Ctrl,T]
# btn:[Save]
:kbd_btn_macro => /\\?(?:kbd|btn):\[((?:\\\]|[^\]])+?)\]/,
# menu:File[New...]
# menu:View[Page Style > No Style]
# menu:View[Page Style, No Style]
:menu_macro => /\\?menu:(\w|\w.*?\S)\[[[:blank:]]*(.+?)?\]/,
# "File > New..."
:menu_inline_macro => /\\?"(\w[^"]*?[[:blank:]]*>[[:blank:]]*[^"[:blank:]][^"]*)"/,
# image::filename.png[Caption]
# video::http://youtube.com/12345[Cats vs Dogs]
:media_blk_macro => /^(image|video|audio)::(\S+?)\[((?:\\\]|[^\]])*?)\]$/,
# image:filename.png[Alt Text]
# image:http://example.com/images/filename.png[Alt Text]
# image:filename.png[More [Alt\] Text] (alt text becomes "More [Alt] Text")
# icon:github[large]
:image_macro => /\\?(?:image|icon):([^:\[][^\[]*)\[((?:\\\]|[^\]])*?)\]/,
# indexterm:[Tigers,Big cats]
# (((Tigers,Big cats)))
:indexterm_macro => /\\?(?:indexterm:(?:\[((?:\\\]|[^\]])*?)\])|\(\(\((.*?)\)\)\)(?!\)))/m,
# indexterm2:[Tigers]
# ((Tigers))
:indexterm2_macro => /\\?(?:indexterm2:(?:\[((?:\\\]|[^\]])*?)\])|\(\((.*?)\)\)(?!\)))/m,
# whitespace at the beginning of the line
:leading_blanks => /^([[:blank:]]*)/,
# leading parent directory references in path
:leading_parent_dirs => /^(?:\.\.\/)*/,
# + From the Asciidoc User Guide: "A plus character preceded by at
# least one space character at the end of a non-blank line forces
# a line break. It generates a line break (br) tag for HTML outputs.
#
# + (would not match because there's no space before +)
# + (would match and capture '')
# Foo + (would and capture 'Foo')
:line_break => /^(.*)[[:blank:]]\+$/,
# inline link and some inline link macro
# FIXME revisit!
:link_inline => %r{(^|link:|\s|>|<|[\(\)\[\]])(\\?(?:https?|ftp|irc)://[^\s\[\]<]*[^\s.,\[\]<])(?:\[((?:\\\]|[^\]])*?)\])?},
# inline link macro
# link:path[label]
:link_macro => /\\?(?:link|mailto):([^\s\[]+)(?:\[((?:\\\]|[^\]])*?)\])/,
# inline email address
# [email protected]
:email_inline => /[\\>:]?\w[\w.%+-]*@[[:alnum:]][[:alnum:].-]*\.[[:alpha:]]{2,4}\b/,
# <TAB>Foo or one-or-more-spaces-or-tabs then whatever
:lit_par => /^([[:blank:]]+.*)$/,
# . Foo (up to 5 consecutive dots)
# 1. Foo (arabic, default)
# a. Foo (loweralpha)
# A. Foo (upperalpha)
# i. Foo (lowerroman)
# I. Foo (upperroman)
# REVIEW leading space has already been stripped, so may not need in regex
:olist => /^[[:blank:]]*(\.{1,5}|\d+\.|[A-Za-z]\.|[IVXivx]+\))[[:blank:]]+(.*)$/,
# ''' (ruler)
# <<< (pagebreak)
:break_line => /^('|<){3,}$/,
# ''' or ' ' ' (ruler)
# --- or - - - (ruler)
# *** or * * * (ruler)
# <<< (pagebreak)
:break_line_plus => /^(?:'|<){3,}$|^ {0,3}([-\*_])( *)\1\2\1$/,
# inline passthrough macros
# +++text+++
# $$text$$
# pass:quotes[text]
:pass_macro => /\\?(?:(\+{3}|\${2})(.*?)\1|pass:([a-z,]*)\[((?:\\\]|[^\]])*?)\])/m,
# passthrough macro allowed in value of attribute assignment
# pass:[text]
:pass_macro_basic => /^pass:([a-z,]*)\[(.*)\]$/,
# inline literal passthrough macro
# `text`
:pass_lit => /(^|[^`\w])(?:\[([^\]]+?)\])?(\\?`([^`\s]|[^`\s].*?\S)`)(?![`\w])/m,
# placeholder for extracted passthrough text
:pass_placeholder => /\e(\d+)\e/,
# The document revision info line the appears immediately following the
# document title author info line, if present
# v1.0, 2013-01-01: Ring in the new year release
:revision_info => /^(?:\D*(.*?),)?(?:\s*(?!:)(.*?))(?:\s*(?!^):\s*(.*))?$/,
# \' within a word
:single_quote_esc => /(\w)\\'(\w)/,
# an alternative if our backend generated single-quoted html/xml attributes
#:single_quote_esc => /(\w|=)\\'(\w)/,
# used for sanitizing attribute names
:illegal_attr_name_chars => /[^\w\-]/,
# 1*h,2*,^3e
:table_colspec => /^(?:(\d+)\*)?([<^>](?:\.[<^>]?)?|(?:[<^>]?\.)?[<^>])?(\d+%?)?([a-z])?$/,
# 2.3+<.>m
# TODO might want to use step-wise scan rather than this mega-regexp
:table_cellspec => {
:start => /^[[:blank:]]*(?:(\d+(?:\.\d*)?|(?:\d*\.)?\d+)([*+]))?([<^>](?:\.[<^>]?)?|(?:[<^>]?\.)?[<^>])?([a-z])?\|/,
:end => /[[:blank:]]+(?:(\d+(?:\.\d*)?|(?:\d*\.)?\d+)([*+]))?([<^>](?:\.[<^>]?)?|(?:[<^>]?\.)?[<^>])?([a-z])?$/
},
# docbook45
# html5
:trailing_digit => /[[:digit:]]+$/,
# .Foo but not . Foo or ..Foo
:blk_title => /^\.([^\s.].*)$/,
# matches double quoted text, capturing quote char and text (single-line)
:dbl_quoted => /^("|)(.*)\1$/,
# matches double quoted text, capturing quote char and text (multi-line)
:m_dbl_quoted => /^("|)(.*)\1$/m,
# == Foo
# ^ yields a level 2 title
#
# == Foo ==
# ^ also yields a level 2 title
#
# both equivalent to this two-line version:
# Foo
# ~~~
#
# match[1] is the delimiter, whose length determines the level
# match[2] is the title itself
# match[3] is an inline anchor, which becomes the section id
:section_title => /^((?:=|#){1,6})\s+(\S.*?)(?:\s*\[\[([^\[]+)\]\])?(?:\s+\1)?$/,
# does not begin with a dot and has at least one alphanumeric character
:section_name => /^((?=.*\w+.*)[^.].*?)$/,
# ====== || ------ || ~~~~~~ || ^^^^^^ || ++++++
# TODO build from SECTION_LEVELS keys
:section_underline => /^(?:=|-|~|\^|\+)+$/,
# toc::[]
# toc::[levels=2]
:toc => /^toc::\[(.*?)\]$/,
# * Foo (up to 5 consecutive asterisks)
# - Foo
# REVIEW leading space has already been stripped, so may not need in regex
:ulist => /^[[:blank:]]*(-|\*{1,5})[[:blank:]]+(.*)$/,
# inline xref macro
# <<id,reftext>> (special characters have already been escaped, hence the entity references)
# xref:id[reftext]
:xref_macro => /\\?(?:<<([\w":].*?)>>|xref:([\w":].*?)\[(.*?)\])/m,
# ifdef::basebackend-html[]
# ifndef::theme[]
# ifeval::["{asciidoctor-version}" >= "0.1.0"]
# ifdef::asciidoctor[Asciidoctor!]
# endif::theme[]
# endif::basebackend-html[]
# endif::[]
:ifdef_macro => /^[\\]?(ifdef|ifndef|ifeval|endif)::(\S*?(?:([,\+])\S+?)?)\[(.+)?\]$/,
# "{asciidoctor-version}" >= "0.1.0"
:eval_expr => /^(\S.*?)[[:blank:]]*(==|!=|<=|>=|<|>)[[:blank:]]*(\S.*)$/,
# ...or if we want to be more strict up front about what's on each side
#:eval_expr => /^(true|false|("|'|)\{\w+(?:\-\w+)*\}\2|("|')[^\3]*\3|\-?\d+(?:\.\d+)*)[[:blank:]]*(==|!=|<=|>=|<|>)[[:blank:]]*(true|false|("|'|)\{\w+(?:\-\w+)*\}\6|("|')[^\7]*\7|\-?\d+(?:\.\d+)*)$/,
# include::chapter1.ad[]
# include::example.txt[lines=1;2;5..10]
:include_macro => /^\\?include::([^\[]+)\[(.*?)\]$/,
# http://domain
# https://domain
# data:info
:uri_sniff => %r{\A[[:alpha:]][[:alnum:].+-]*:/*},
:uri_encode_chars => /[^\w\-.!~*';:@=+$,()\[\]]/,
:mantitle_manvolnum => /^(.*)\((.*)\)$/,
:manname_manpurpose => /^(.*?)[[:blank:]]+-[[:blank:]]+(.*)$/
}
INTRINSICS = Hash.new{|h,k| STDERR.puts "Missing intrinsic: #{k.inspect}"; "{#{k}}"}.merge(
{
'startsb' => '[',
'endsb' => ']',
'brvbar' => '|',
'caret' => '^',
'asterisk' => '*',
'tilde' => '~',
'plus' => '+',
'apostrophe' => '\'',
'backslash' => '\\',
'backtick' => '`',
'empty' => '',
'sp' => ' ',
'space' => ' ',
'two-colons' => '::',
'two-semicolons' => ';;',
'nbsp' => ' ',
'deg' => '°',
'zwsp' => '​',
'quot' => '"',
'apos' => ''',
'lsquo' => '‘',
'rsquo' => '’',
'ldquo' => '“',
'rdquo' => '”',
'wj' => '⁠',
'amp' => '&',
'lt' => '<',
'gt' => '>'
}
)
SPECIAL_CHARS = {
'<' => '<',
'>' => '>',
'&' => '&'
}
SPECIAL_CHARS_PATTERN = /[#{SPECIAL_CHARS.keys.join}]/
#SPECIAL_CHARS_PATTERN = /(?:<|>|&(?![[:alpha:]]{2,};|#[[:digit:]]{2,}+;|#x[[:alnum:]]{2,}+;))/
# unconstrained quotes:: can appear anywhere
# constrained quotes:: must be bordered by non-word characters
# NOTE these substituions are processed in the order they appear here and
# the order in which they are replaced is important
QUOTE_SUBS = [
# **strong**
[:strong, :unconstrained, /\\?(?:\[([^\]]+?)\])?\*\*(.+?)\*\*/m],
# *strong*
[:strong, :constrained, /(^|[^\w;:}])(?:\[([^\]]+?)\])?\*(\S|\S.*?\S)\*(?=\W|$)/m],
# ``double-quoted''
[:double, :constrained, /(^|[^\w;:}])(?:\[([^\]]+?)\])?``(\S|\S.*?\S)''(?=\W|$)/m],
# 'emphasis'
[:emphasis, :constrained, /(^|[^\w;:}])(?:\[([^\]]+?)\])?'(\S|\S.*?\S)'(?=\W|$)/m],
# `single-quoted'
[:single, :constrained, /(^|[^\w;:}])(?:\[([^\]]+?)\])?`(\S|\S.*?\S)'(?=\W|$)/m],
# ++monospaced++
[:monospaced, :unconstrained, /\\?(?:\[([^\]]+?)\])?\+\+(.+?)\+\+/m],
# +monospaced+
[:monospaced, :constrained, /(^|[^\w;:}])(?:\[([^\]]+?)\])?\+(\S|\S.*?\S)\+(?=\W|$)/m],
# __emphasis__
[:emphasis, :unconstrained, /\\?(?:\[([^\]]+?)\])?\_\_(.+?)\_\_/m],
# _emphasis_
[:emphasis, :constrained, /(^|[^\w;:}])(?:\[([^\]]+?)\])?_(\S|\S.*?\S)_(?=\W|$)/m],
# ##unquoted##
[:none, :unconstrained, /\\?(?:\[([^\]]+?)\])?##(.+?)##/m],
# #unquoted#
[:none, :constrained, /(^|[^\w;:}])(?:\[([^\]]+?)\])?#(\S|\S.*?\S)#(?=\W|$)/m],
# ^superscript^
[:superscript, :unconstrained, /\\?(?:\[([^\]]+?)\])?\^(.+?)\^/m],
# ~subscript~
[:subscript, :unconstrained, /\\?(?:\[([^\]]+?)\])?\~(.+?)\~/m]
]
# NOTE in Ruby 1.8.7, [^\\] does not match start of line,
# so we need to match it explicitly
# order is significant
REPLACEMENTS = [
# (C)
[/\\?\(C\)/, '©', :none],
# (R)
[/\\?\(R\)/, '®', :none],
# (TM)
[/\\?\(TM\)/, '™', :none],
# foo -- bar
[/(^|\n| |\\)--( |\n|$)/, ' — ', :none],
# foo--bar
[/(\w)\\?--(?=\w)/, '—', :leading],
# ellipsis
[/\\?\.\.\./, '…', :leading],
# single quotes
[/(\w)\\?'(\w)/, '’', :bounding],
# right arrow ->
[/\\?->/, '→', :none],
# right double arrow =>
[/\\?=>/, '⇒', :none],
# left arrow <-
[/\\?<-/, '←', :none],
# right left arrow <=
[/\\?<=/, '⇐', :none],
# restore entities
[/\\?(&)amp;((?:[[:alpha:]]+|#[[:digit:]]+|#x[[:alnum:]]+);)/, '', :bounding]
]
# Public: Parse the AsciiDoc source input into an Asciidoctor::Document
#
# Accepts input as an IO (or StringIO), String or String Array object. If the
# input is a File, information about the file is stored in attributes on the
# Document object.
#
# input - the AsciiDoc source as a IO, String or Array.
# options - a String, Array or Hash of options to control processing (default: {})
# String and Array values are converted into a Hash.
# See Asciidoctor::Document#initialize for details about options.
#
# returns the Asciidoctor::Document
def self.load(input, options = {})
if (monitor = options.fetch(:monitor, false))
start = Time.now
end
attrs = (options[:attributes] ||= {})
if attrs.is_a?(Hash) || (RUBY_ENGINE == 'jruby' && attrs.is_a?(Java::JavaUtil::Map))
# all good; placed here as optimization
elsif attrs.is_a? Array
attrs = options[:attributes] = attrs.inject({}) do |accum, entry|
k, v = entry.split '=', 2
accum[k] = v || ''
accum
end
elsif attrs.is_a? String
# convert non-escaped spaces into null character, so we split on the
# correct spaces chars, and restore escaped spaces
attrs = attrs.gsub(REGEXP[:space_delim], "\\1\0").gsub(REGEXP[:escaped_space], '\1')
attrs = options[:attributes] = attrs.split("\0").inject({}) do |accum, entry|
k, v = entry.split '=', 2
accum[k] = v || ''
accum
end
elsif attrs.respond_to?('keys') && attrs.respond_to?('[]')
# convert it to a Hash as we know it
original_attrs = attrs
attrs = options[:attributes] = {}
original_attrs.keys.each do |key|
attrs[key] = original_attrs[key]
end
else
raise ArgumentError, "illegal type for attributes option: #{attrs.class.ancestors}"
end
lines = nil
if input.is_a? File
lines = input.readlines
input_mtime = input.mtime
input_path = File.expand_path(input.path)
# hold off on setting infile and indir until we get a better sense of their purpose
attrs['docfile'] = input_path
attrs['docdir'] = File.dirname(input_path)
attrs['docname'] = File.basename(input_path, File.extname(input_path))
attrs['docdate'] = docdate = input_mtime.strftime('%Y-%m-%d')
attrs['doctime'] = doctime = input_mtime.strftime('%H:%M:%S %Z')
attrs['docdatetime'] = %(#{docdate} #{doctime})
elsif input.respond_to?(:readlines)
input.rewind rescue nil
lines = input.readlines
elsif input.is_a?(String)
lines = input.lines.entries
elsif input.is_a?(Array)
lines = input.dup
else
raise "Unsupported input type: #{input.class}"
end
if monitor
read_time = Time.now - start
start = Time.now
end
doc = Document.new(lines, options)
if monitor
parse_time = Time.now - start
monitor[:read] = read_time
monitor[:parse] = parse_time
monitor[:load] = read_time + parse_time
end
doc
end
# Public: Parse the contents of the AsciiDoc source file into an Asciidoctor::Document
#
# Accepts input as an IO, String or String Array object. If the
# input is a File, information about the file is stored in
# attributes on the Document.
#
# input - the String AsciiDoc source filename
# options - a String, Array or Hash of options to control processing (default: {})
# String and Array values are converted into a Hash.
# See Asciidoctor::Document#initialize for details about options.
#
# returns the Asciidoctor::Document
def self.load_file(filename, options = {})
Asciidoctor.load(File.new(filename), options)
end
# Public: Parse the AsciiDoc source input into an Asciidoctor::Document and render it
# to the specified backend format
#
# Accepts input as an IO, String or String Array object. If the
# input is a File, information about the file is stored in
# attributes on the Document.
#
# If the :in_place option is true, and the input is a File, the output is
# written to a file adjacent to the input file, having an extension that
# corresponds to the backend format. Otherwise, if the :to_file option is
# specified, the file is written to that file. If :to_file is not an absolute
# path, it is resolved relative to :to_dir, if given, otherwise the
# Document#base_dir. If the target directory does not exist, it will not be
# created unless the :mkdirs option is set to true. If the file cannot be
# written because the target directory does not exist, or because it falls
# outside of the Document#base_dir in safe mode, an IOError is raised.
#
# If the output is going to be written to a file, the header and footer are
# rendered unless specified otherwise (writing to a file implies creating a
# standalone document). Otherwise, the header and footer are not rendered by
# default and the rendered output is returned.
#
# input - the String AsciiDoc source filename
# options - a String, Array or Hash of options to control processing (default: {})
# String and Array values are converted into a Hash.
# See Asciidoctor::Document#initialize for details about options.
#
# returns the Document object if the rendered result String is written to a
# file, otherwise the rendered result String
def self.render(input, options = {})
in_place = options.delete(:in_place) || false
to_file = options.delete(:to_file)
to_dir = options.delete(:to_dir)
mkdirs = options.delete(:mkdirs) || false
monitor = options.fetch(:monitor, false)
write_in_place = in_place && input.is_a?(File)
write_to_target = to_file || to_dir
stream_output = !to_file.nil? && to_file.respond_to?(:write)
if write_in_place && write_to_target
raise ArgumentError, 'the option :in_place cannot be used with either the :to_dir or :to_file option'
end
if !options.has_key?(:header_footer) && (write_in_place || write_to_target)
options[:header_footer] = true
end
doc = Asciidoctor.load(input, options)
if to_file == '/dev/null'
return doc
elsif write_in_place
to_file = File.join(File.dirname(input.path), "#{doc.attributes['docname']}#{doc.attributes['outfilesuffix']}")
elsif !stream_output && write_to_target
working_dir = options.has_key?(:base_dir) ? File.expand_path(options[:base_dir]) : File.expand_path(Dir.pwd)
# QUESTION should the jail be the working_dir or doc.base_dir???
jail = doc.safe >= SafeMode::SAFE ? working_dir : nil
if to_dir
to_dir = doc.normalize_system_path(to_dir, working_dir, jail, :target_name => 'to_dir', :recover => false)
if to_file
to_file = doc.normalize_system_path(to_file, to_dir, nil, :target_name => 'to_dir', :recover => false)
# reestablish to_dir as the final target directory (in the case to_file had directory segments)
to_dir = File.dirname(to_file)
else
to_file = File.join(to_dir, "#{doc.attributes['docname']}#{doc.attributes['outfilesuffix']}")
end
elsif to_file
to_file = doc.normalize_system_path(to_file, working_dir, jail, :target_name => 'to_dir', :recover => false)
# establish to_dir as the final target directory (in the case to_file had directory segments)
to_dir = File.dirname(to_file)
end
if !File.directory? to_dir
if mkdirs
Helpers.require_library 'fileutils'
FileUtils.mkdir_p to_dir
else
raise IOError, "target directory does not exist: #{to_dir}"
end
end
end
start = Time.now if monitor
output = doc.render
if monitor
render_time = Time.now - start
monitor[:render] = render_time
monitor[:load_render] = monitor[:load] + render_time
end
if to_file
start = Time.now if monitor
if stream_output
to_file.write output.rstrip
# ensure there's a trailing endline
to_file.write EOL
else
File.open(to_file, 'w') {|file| file.write output }
# these assignments primarily for testing, diagnostics or reporting
doc.attributes['outfile'] = outfile = File.expand_path(to_file)
doc.attributes['outdir'] = File.dirname(outfile)
end
if monitor
write_time = Time.now - start
monitor[:write] = write_time
monitor[:total] = monitor[:load_render] + write_time
end
# NOTE document cannot control this behavior if safe >= SafeMode::SERVER
if !stream_output && doc.safe < SafeMode::SECURE && (doc.attr? 'basebackend-html') &&
(doc.attr? 'linkcss') && (doc.attr? 'copycss')
copy_asciidoctor_stylesheet = DEFAULT_STYLESHEET_KEYS.include?(stylesheet = (doc.attr 'stylesheet'))
#copy_user_stylesheet = !copy_asciidoctor_stylesheet && (doc.attr? 'copycss')
copy_coderay_stylesheet = (doc.attr? 'source-highlighter', 'coderay') && (doc.attr 'coderay-css', 'class') == 'class'
copy_pygments_stylesheet = (doc.attr? 'source-highlighter', 'pygments') && (doc.attr 'pygments-css', 'class') == 'class'
if copy_asciidoctor_stylesheet || copy_coderay_stylesheet || copy_pygments_stylesheet
Helpers.require_library 'fileutils'
outdir = doc.attr('outdir')
stylesdir = doc.normalize_system_path(doc.attr('stylesdir'), outdir,
doc.safe >= SafeMode::SAFE ? outdir : nil)
Helpers.mkdir_p stylesdir if mkdirs
if copy_asciidoctor_stylesheet
File.open(File.join(stylesdir, DEFAULT_STYLESHEET_NAME), 'w') {|f|
f.write Asciidoctor::HTML5.default_asciidoctor_stylesheet
}
end
#if copy_user_stylesheet
#end
if copy_coderay_stylesheet
File.open(File.join(stylesdir, 'asciidoctor-coderay.css'), 'w') {|f|
f.write Asciidoctor::HTML5.default_coderay_stylesheet
}
end
if copy_pygments_stylesheet
File.open(File.join(stylesdir, 'asciidoctor-pygments.css'), 'w') {|f|
f.write Asciidoctor::HTML5.pygments_stylesheet(doc.attr 'pygments-style')
}
end
end
end
if !stream_output && doc.safe < SafeMode::SECURE && (doc.attr? 'basebackend-htmlbook') &&
(doc.attr? 'linkcss') && (doc.attr? 'copycss')
copy_asciidoctor_stylesheet = DEFAULT_STYLESHEET_KEYS.include?(stylesheet = (doc.attr 'stylesheet'))
#copy_user_stylesheet = !copy_asciidoctor_stylesheet && (doc.attr? 'copycss')
copy_coderay_stylesheet = (doc.attr? 'source-highlighter', 'coderay') && (doc.attr 'coderay-css', 'class') == 'class'
copy_pygments_stylesheet = (doc.attr? 'source-highlighter', 'pygments') && (doc.attr 'pygments-css', 'class') == 'class'
if copy_asciidoctor_stylesheet || copy_coderay_stylesheet || copy_pygments_stylesheet
Helpers.require_library 'fileutils'
outdir = doc.attr('outdir')
stylesdir = doc.normalize_system_path(doc.attr('stylesdir'), outdir,
doc.safe >= SafeMode::SAFE ? outdir : nil)
Helpers.mkdir_p stylesdir if mkdirs
if copy_asciidoctor_stylesheet
File.open(File.join(stylesdir, DEFAULT_STYLESHEET_NAME), 'w') {|f|
f.write Asciidoctor::HTMLBook.default_asciidoctor_stylesheet
}
end
#if copy_user_stylesheet
#end
if copy_coderay_stylesheet
File.open(File.join(stylesdir, 'asciidoctor-coderay.css'), 'w') {|f|
f.write Asciidoctor::HTMLBook.default_coderay_stylesheet
}
end
if copy_pygments_stylesheet
File.open(File.join(stylesdir, 'asciidoctor-pygments.css'), 'w') {|f|
f.write Asciidoctor::HTMLBook.pygments_stylesheet(doc.attr 'pygments-style')
}
end
end
end
doc
else
output
end
end
# Public: Parse the contents of the AsciiDoc source file into an Asciidoctor::Document
# and render it to the specified backend format
#
# input - the String AsciiDoc source filename
# options - a String, Array or Hash of options to control processing (default: {})
# String and Array values are converted into a Hash.
# See Asciidoctor::Document#initialize for details about options.
#
# returns the Document object if the rendered result String is written to a
# file, otherwise the rendered result String
def self.render_file(filename, options = {})
Asciidoctor.render(File.new(filename), options)
end
# modules
require 'orm_asciidoctor/debug'
require 'orm_asciidoctor/substituters'
require 'orm_asciidoctor/helpers'
# abstract classes
require 'orm_asciidoctor/abstract_node'
require 'orm_asciidoctor/abstract_block'
# concrete classes
require 'orm_asciidoctor/attribute_list'
require 'orm_asciidoctor/backends/base_template'
require 'orm_asciidoctor/block'
require 'orm_asciidoctor/callouts'
require 'orm_asciidoctor/document'
require 'orm_asciidoctor/inline'
require 'orm_asciidoctor/lexer'
require 'orm_asciidoctor/list'
require 'orm_asciidoctor/path_resolver'
require 'orm_asciidoctor/reader'
require 'orm_asciidoctor/renderer'
require 'orm_asciidoctor/section'
require 'orm_asciidoctor/table'
# info
require 'orm_asciidoctor/version'
end
|
|
|
|
|
fb8ef83325d631383360c1adf5cff235fb28d90c
|
|
|
|
src/pal/tests/palsuite/threading/SwitchToThread/test1/test1.c
|
|
83b2cb83b32faa45b4f790237b5c5e259692294a
|
|
|
|
|
src/pal/tests/palsuite/threading/SwitchToThread/test1/test1.c
|
|
83b2cb83b32faa45b4f790237b5c5e259692294a
|
|
|
|
|
src/pal/tests/palsuite/threading/SwitchToThread/test1/test1.c
|
|
83b2cb83b32faa45b4f790237b5c5e259692294a
|
|
|
|
|
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
/*=============================================================================
**
** Source: test1.c
**
** Purpose: Test to ensure SwitchToThread works, without
** causing test to hang
**
** Dependencies: PAL_Initialize
** Fail
** SwitchToThread
** WaitForMultipleObject
** CreateThread
** GetLastError
**
**
**===========================================================================*/
#include <palsuite.h>
#define THREAD_COUNT 10
#define REPEAT_COUNT 1000
#define TIMEOUT 60000
void PALAPI Run_Thread(LPVOID lpParam);
/**
* main
*
* executable entry point
*/
INT __cdecl main( INT argc, CHAR **argv )
{
DWORD dwParam;
HANDLE hThread[THREAD_COUNT];
DWORD threadId[THREAD_COUNT];
int i = 0;
int returnCode = 0;
/*PAL initialization */
if( (PAL_Initialize(argc, argv)) != 0 )
{
return FAIL;
}
for( i = 0; i < THREAD_COUNT; i++ )
{
dwParam = (int) i;
//Create thread
hThread[i] = CreateThread(
NULL, /* no security attributes */
0, /* use default stack size */
(LPTHREAD_START_ROUTINE)Run_Thread,/* thread function */
(LPVOID)dwParam, /* argument to thread function */
0, /* use default creation flags */
&threadId[i] /* returns the thread identifier*/
);
if(hThread[i] == NULL)
{
Fail("Create Thread failed for iteration %d GetLastError value is %d\n", i, GetLastError());
}
}
returnCode = WaitForMultipleObjects(THREAD_COUNT, hThread, TRUE, TIMEOUT);
if( WAIT_OBJECT_0 != returnCode )
{
Trace("Wait for Object(s) returned %d, expected value is %d, and GetLastError value is %d\n", returnCode, WAIT_OBJECT_0, GetLastError());
}
PAL_Terminate();
return PASS;
}
void PALAPI Run_Thread (LPVOID lpParam)
{
int i = 0;
int Id=(int)lpParam;
for(i=0; i < REPEAT_COUNT; i++ )
{
// No Last Error is set..
if(!SwitchToThread())
{
Trace( "The operating system did not switch execution to another thread,"
"for thread id[%d], iteration [%d]\n", Id, i );
}
}
}
|
|
|
|
|
15b1bd569f5f103bf58c3e319ea2f77c1372ccb0
|
|
|
|
lib/src/main/kotlin/com/amarland/iconvector/lib/Utils.kt
|
|
e05c63280dc922ce6bd3ea961c53ce1f9a415213
|
|
|
|
|
lib/src/main/kotlin/com/amarland/iconvector/lib/Utils.kt
|
|
e05c63280dc922ce6bd3ea961c53ce1f9a415213
|
|
|
|
|
lib/src/main/kotlin/com/amarland/iconvector/lib/Utils.kt
|
|
e05c63280dc922ce6bd3ea961c53ce1f9a415213
|
|
|
|
|
/*
* Copyright 2021 Anthony Marland
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.amarland.iconvector.lib
import kotlin.math.roundToInt
import com.amarland.iconvector.lib.IconVGIntermediateRepresentation as IR
internal fun IntArray.insert(index: Int, value: Int): IntArray {
require(index in 0..size)
return IntArray(size + 1).apply {
val source = this@insert
val destination = this
destination[index] = value
if (index == 0) {
System.arraycopy(source, 0, destination, 1, source.size)
} else {
System.arraycopy(source, 0, destination, 0, index)
if (index < source.size - 1) {
System.arraycopy(source, index, destination, index + 1, source.size - index)
}
}
}
}
internal fun FloatArray.insert(index: Int, value: Float): FloatArray {
require(index in 0..size)
return FloatArray(size + 1).apply {
val source = this@insert
val destination = this
destination[index] = value
if (index == 0) {
System.arraycopy(source, 0, destination, 1, source.size)
} else {
System.arraycopy(source, 0, destination, 0, index)
if (index < source.size - 1) {
System.arraycopy(source, index, destination, index + 1, source.size - index)
}
}
}
}
fun argbColorToHexString(argb: UInt) =
'#' + ((((argb shr 24) / 255U) * (argb and 0x00FFFFFFU)).toString(16)
.padStart(length = 6, padChar = '0'))
fun Iterable<IR.Path.Segment>.toSvgPathDataString(decimalPlaces: Int = Int.MAX_VALUE) =
buildString {
joinTo(this, separator = " ") { segment ->
var index = 0
segment.arguments.joinToString(
separator = " ",
prefix = "${segment.command.value} "
) { value ->
if (segment.command == IR.Path.Command.ARC_TO && (index == 3 || index == 4)) {
value.roundToInt().toString()
} else if (decimalPlaces in 0..5) {
"%.${decimalPlaces}f".format(value)
} else {
value.toString()
}.also { index++ }
}
}
}
|
|
|
|
|
8588ad3fb52fe92ae1e82e6a5e5390afc41987b0
|
|
|
|
|
|
cac4488165bc1379d26d948cc8b448d6ef03c53c
|
|
|
|
|
|
|
cac4488165bc1379d26d948cc8b448d6ef03c53c
|
|
|
|
|
|
|
cac4488165bc1379d26d948cc8b448d6ef03c53c
|
|
|
|
|
import * as path from 'path'
import * as fs from 'fs'
import cp from 'child_process'
import typescript from '@rollup/plugin-typescript'
import externals from 'rollup-plugin-node-externals'
import pkg from './package.json'
const isEnvDevelopment = process.env.NODE_ENV === 'development'
const input = 'src/index.ts'
const webpackPlugin = `@ices/theme-webpack-plugin`
const sourcemap = !isEnvDevelopment || 'inline'
function writeFileSync(filePath, content) {
const unExistsDirs = []
let file = filePath
while (!fs.existsSync((file = path.dirname(file)))) {
unExistsDirs.unshift(file)
}
for (const dir of unExistsDirs) {
fs.mkdirSync(dir)
}
fs.writeFileSync(filePath, content)
}
function makeFakeThemeFile() {
writeFileSync(
path.join(path.resolve(path.dirname(pkg.main)), 'theme.js'),
`// Auto generated code
throw new Error(
\`Please add ThemeWebpackPlugin from '${webpackPlugin}' to your config of webpack first:
// webpack.config.js
const ThemeWebpackPlugin = require('${webpackPlugin}')
module.exports = {
plugins: [new ThemeWebpackPlugin()]
}\`
)
`
)
}
function makeTypesFile() {
cp.execSync('yarn types', { stdio: 'ignore' })
const paths = ['types/react', 'types/vue']
for (const p of paths) {
const dir = path.resolve(p)
if (fs.existsSync(dir)) {
for (const dts of fs.readdirSync(dir)) {
fs.renameSync(path.join(dir, dts), path.join(path.resolve(p.replace(/^types\//, '')), dts))
}
}
}
}
function getPlugins(format, makeTypes) {
return [
externals({
builtins: true,
deps: true,
peerDeps: true,
exclude: 'tslib',
}),
typescript({
removeComments: true,
noUnusedLocals: !isEnvDevelopment,
target: 'es5',
}),
makeTypes && {
name: 'make-types',
generateBundle: makeTypesFile,
},
].filter(Boolean)
}
makeFakeThemeFile()
export default [
{
input,
external: ['./theme'],
output: {
file: pkg.module,
format: 'es',
sourcemap,
},
plugins: getPlugins('es'),
},
{
input,
external: ['./theme'],
output: {
file: pkg.main,
exports: 'auto',
format: 'cjs',
sourcemap,
},
plugins: getPlugins('cjs'),
},
{
input: 'src/react/index.tsx',
external: ['../index'],
output: {
file: 'react/index.js',
paths: (id) => {
if (id === path.resolve('src/index')) {
return path.relative(path.resolve('react'), path.resolve(pkg.module)).replace(/\\/g, '/')
}
return id
},
format: 'es',
sourcemap,
},
plugins: getPlugins('es'),
},
{
input: 'src/react/index.tsx',
external: ['../index'],
output: {
file: 'react/index.cjs.js',
paths: (id) => {
if (id === path.resolve('src/index')) {
return path.relative(path.resolve('react'), path.resolve(pkg.main)).replace(/\\/g, '/')
}
return id
},
exports: 'auto',
format: 'cjs',
sourcemap,
},
plugins: getPlugins('cjs', true),
},
]
|
|
|
|
|
a101f6805c4eee7efe596729930038f01c347ba2
|
|
|
|
|
Mystic-Developer/FizzBuzz-EVERYTHING
|
2daed09d9d7b5e25e1027b7a740c179e653f74af
|
|
|
|
|
|
Mystic-Developer/FizzBuzz-EVERYTHING
|
2daed09d9d7b5e25e1027b7a740c179e653f74af
|
|
|
|
|
|
Mystic-Developer/FizzBuzz-EVERYTHING
|
2daed09d9d7b5e25e1027b7a740c179e653f74af
|
|
|
|
|
.data
fizz: .asciiz "Fizz"
buzz: .asciiz "Buzz"
fizzbuzz: .asciiz "FizzBuzz"
new_line: .asciiz "\n"
prompt: .asciiz "Please enter the highest number you want to go for FizzBuzz: "
.text
addi $s0, $zero, 5 # s0 = 5;
addi $s1, $zero, 3 # s1 = 3;
addi $t0, $zero, 1 # t0 = 1; This will be the while loop counter!
# sends user prompt message
li $v0, 4
la $a0, prompt
syscall
# gets number from user and stores it in $v0
li $v0, 5
syscall
# moves users input from $v0 to $s4
move $s4, $v0
while:
bgt $t0, $s4, exit # while t0 < 100
div $t0, $s1 # divide $t0 by 3
mfhi $s2 # store the remainder of $t0 / 3 in $s2
div $t0, $s0 # divide $t0 by 5
mfhi $s3 # store the remainder of $t0 / 5 in $s3
beq $s2, $zero, three_is_good_check_five_for_fizzbuzz # if $s2 is equal to 0, then go check $s3 and see if remainder of 5 checks out for fizzbuzz
five_wasnt_good_continue_looping: # if s3 didn't check out for fizzbuzz return to this point of while loop
div $t0, $s1 # divide $t0 by 3
mfhi $s2 # store the remainder of $t0 / 3 in $s2
beq $s2, $zero, print_fizz #if $s2 is equal to 0, then print fizz
div $t0, $s0 # divide $t0 by 5
mfhi $s2 # store the remainder of $t0 / 5 in $s2
beq $s2, $zero, print_buzz # if $s2 is equal to 0, then print buzz
# prints $t0 current number
li $v0, 1
add $a0, $t0, $zero
syscall
# prints a newline
li $v0, 4
la $a0, new_line
syscall
addi $t0, $t0, 1 # increases t0 counter by 1
j while # jumps back to top of while loop
three_is_good_check_five_for_fizzbuzz:
beq $s3, $zero, print_fizzbuzz # checks to see if the remainder of t0/5, stored in $s3 is 0. If so jumps to print fizzbuzz!
j five_wasnt_good_continue_looping # if it wasnt 0, then you return to the while loop
print_fizzbuzz:
# prints fizzbuzz
li $v0, 4
la $a0, fizzbuzz
syscall
# prints a newline
li $v0, 4
la $a0, new_line
syscall
addi $t0, $t0, 1 # increases t0 counter by 1
j while # jumps back to top of while loop
print_fizz:
# prints fizz
li $v0, 4
la $a0, fizz
syscall
# prints a newline
li $v0, 4
la $a0, new_line
syscall
addi $t0, $t0, 1 # increases t0 counter by 1
j while # jumps back to top of while loop
print_buzz:
#prints buzz
li $v0, 4
la $a0, buzz
syscall
# prints a newline
li $v0, 4
la $a0, new_line
syscall
addi $t0, $t0, 1 # increases t0 counter by 1
j while # jumps back to top of while loop
exit:
# ends program
li $v0, 10
syscall
|
|
|
|
|
0b6ffbf766a563164a019a52f34be9e1263ae173
|
|
|
|
|
|
8cb6c22871fcddb633392c0a12691e960dad5143
|
|
|
|
|
|
|
8cb6c22871fcddb633392c0a12691e960dad5143
|
|
|
|
|
|
|
8cb6c22871fcddb633392c0a12691e960dad5143
|
|
|
|
|
import xxhash
import numpy as np
from base.grid import SimpleGRID
import scipy.sparse as SP
h = xxhash.xxh64()
s_to_i = lambda x,size : size*x[0]+x[1]
i_to_s = lambda x,size : (x%size,x//size)
def hash(x):
h.reset()
h.update(x)
return h.digest()
class Indexer(object):
def __init__(self):
self.total = 0
self.dict = {}
def get(self,hs):
val = self.dict.get(hs,-1)
if val == -1:
val = self.total
self.dict[hs] = val
self.total += 1
return val
def reset(self):
self.__init__()
class HashIndexer(object):
def __init__(self):
self.total = 0
self.dict = {}
def get(self,state):
hs=hash(state)
val = self.dict.get(hs,-1)
if val == -1:
val = self.total
self.dict[hs] = val
self.total += 1
return val
def reset(self):
self.__init__()
def get_graph(size):
env = SimpleGRID(grid_size=size,max_time=5000)
input_shape = env.observation_space.shape
min_batch = size**2-size
indexer = Indexer()
W = np.zeros((min_batch,min_batch))
states = np.zeros(min_batch).astype(int)
data = np.zeros((min_batch,)+input_shape)
while indexer.total<min_batch:
done = False
s = env.reset()
#s = s.transpose(2,0,1)#np.expand_dims(s,axis=0)
i = indexer.get(s_to_i(env.get_cat(),size))
states[i] = s_to_i(env.get_cat(),size)
data[states[i]] = s
while not done:
s,r,done = env.step(np.random.randint(4))
#s = np.expand_dims(s,axis=0)
#s = s.transpose(-1,0,1)
j = indexer.get(s_to_i(env.get_cat(),size))
states[j] = s_to_i(env.get_cat(),size)
data[states[j]] = s
W[states[i],states[j]] = W[states[j],states[i]] = 1
if r==1:
print(s_to_i(env.get_cat(),size),indexer.total)
i = j
return data, W
class GraphBuilder(object):
def __init__(self, env, action_set, batch_size):
self.env = env
self.action_set = action_set
self.h = xxhash.xxh64()
self.max_size = batch_size
self.indices = set()
self._total = 0
self.dict = {}
self.states = []
self.prev = 0
self.roll = self.roller()
def submit(self,state, new=False):
hs = self.hash(state)
val = self.dict.get(hs,-1)
if val == -1:
self.states.append(state)
val = self._total
self.dict[hs] = self._total
self._total += 1
if not new:
self.indices.add((self.prev,val))
self.prev = val
def reset(self):
self.indices = set()
self._total = 0
self.dict = {}
self.states = []
self.prev = 0
def roller(self):
done = True
while True:
self.reset()
while not self.full:
if done:
s = self.env.reset()
self.submit(s.copy(), new=done)
done = False
while not done and not self.full:
s,_,done,_ = self.env.step(np.random.choice(self.action_set))
self.submit(s.copy())
S,W = self.get_graph()
W = W.toarray()
#W = (W+W.T)/2
W = np.maximum(W,W.T)
#np.fill_diagonal(W, 1)
yield S, W
def get(self):
return self.roll.__next__()
def hash(self,x):
self.h.reset()
self.h.update(x)
return self.h.digest()
def get_graph(self):
if not self.full:
raise "Graph not full Yet"
indices = np.array(list(self.indices))
rows = indices[:,0]
cols = indices[:,1]
data = np.ones(len(rows))
return np.array(self.states),SP.coo_matrix((data, (rows, cols)),shape=(self.max_size, self.max_size))
@property
def size(self):
return self._total
@property
def full(self):
return self.size == self.max_size
|
|
|
|
|
653e20753803cf3d8c774a1a90f5c5407a146bd4
|
|
|
|
|
changshuowang/PersistenceNetwork
|
519aa3b4a123091ae6cc3cf619182b5be54fcac3
|
|
|
|
|
|
changshuowang/PersistenceNetwork
|
519aa3b4a123091ae6cc3cf619182b5be54fcac3
|
|
|
|
|
|
changshuowang/PersistenceNetwork
|
519aa3b4a123091ae6cc3cf619182b5be54fcac3
|
|
|
|
|
import numpy as np
from sklearn.metrics import average_precision_score as ap
from sklearn.metrics import roc_auc_score
"""
each row is an instance
each column is the prediction of a class
"""
def _score_to_rank(score_list):
rank_array = np.zeros([len(score_list)])
score_array = np.array(score_list)
idx_sorted = (-score_array).argsort()
rank_array[idx_sorted] = np.arange(len(score_list))+1
rank_list = rank_array.tolist()
return rank_list
# For clip evaluation
def auc_y_classwise(Y_target, Y_score):
"""
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
# Y_target = np.squeeze(np.array(Y_target))
# Y_score = np.squeeze(np.array(Y_score))
Y_target = np.array(Y_target)
Y_score = np.array(Y_score)
auc_list = roc_auc_score(Y_target, Y_score, average=None)
return auc_list
def ap_y_classwise(Y_target, Y_score):
"""
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
# Y_target = np.squeeze(np.array(Y_target))
# Y_score = np.squeeze(np.array(Y_score))
Y_target = np.array(Y_target)
Y_score = np.array(Y_score)
ap_list = ap(Y_target, Y_score, average=None)
return ap_list
def auc(Y_target, Y_score):
"""
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
Y_target = np.array(Y_target)
Y_score = np.array(Y_score)
auc_list = []
for i in range(Y_score.shape[1]):
try:
auc = roc_auc_score(Y_target[:, i], Y_score[:, i])
except:
continue
auc_list.append(auc)
return auc_list
def mean_auc(Y_target, Y_score):
auc_list = auc(Y_target, Y_score)
mean_auc = np.mean(auc_list)
return mean_auc
def mean_auc_y(Y_target, Y_score):
'''
along y-axis
'''
return mean_auc(Y_target, Y_score)
def mean_auc_x(Y_target, Y_score):
'''
along x-axis
'''
return mean_auc(np.array(Y_target).T, np.array(Y_score).T)
def mean_average_precision(Y_target, Y_score):
"""
mean average precision
raw-based operation
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
p = float(len(Y_target))
temp_sum = 0
for y_target, y_score in zip(Y_target, Y_score):
y_target = np.array(y_target)
y_score = np.array(y_score)
if (y_target == 0).all() or (y_target == 1).all():
p -= 1
continue
idx_target = np.nonzero(y_target > 0)[0]
n_target = float(len(idx_target))
rank_list = np.array(_score_to_rank(y_score))
target_rank_list = rank_list[idx_target]
temp_sum_2 = 0
for target_rank in target_rank_list:
mm = sum([1 for ii in idx_target
if rank_list[ii] <= target_rank])/float(target_rank)
temp_sum_2 += mm
temp_sum += temp_sum_2/n_target
measure = temp_sum/p
return measure
def map(Y_target, Y_score):
return mean_average_precision(Y_target, Y_score)
def map_x(Y_target, Y_score):
return mean_average_precision(Y_target, Y_score)
def map_y(Y_target, Y_score):
return mean_average_precision(np.array(Y_target).T,
np.array(Y_score).T)
|
|
|
|
|
dfe7872eca28b5a45f2dcfe0d8b6eff301974230
|
|
|
|
packages/@glimmer/syntax/lib/traversal/traverse.ts
|
|
e30b3d64232a0972365c8cbb1dd8e236a0f33dcf
|
|
|
|
|
packages/@glimmer/syntax/lib/traversal/traverse.ts
|
|
e30b3d64232a0972365c8cbb1dd8e236a0f33dcf
|
|
|
|
|
packages/@glimmer/syntax/lib/traversal/traverse.ts
|
|
e30b3d64232a0972365c8cbb1dd8e236a0f33dcf
|
|
|
|
|
import visitorKeys from '../types/visitor-keys';
import {
cannotRemoveNode,
cannotReplaceNode,
cannotReplaceOrRemoveInKeyHandlerYet,
} from './errors';
import { Node, NodeType, ParentNode, ChildKey } from '../types/nodes';
import { NodeVisitor, NodeFunction, NodeHandler, KeyFunction, KeyHandler } from '../types/visitor';
function getEnterFunction(handler: KeyHandler): KeyFunction | undefined;
function getEnterFunction(handler: NodeHandler): NodeFunction | undefined;
function getEnterFunction(
handler: NodeHandler | KeyHandler
): NodeFunction | KeyFunction | undefined {
return typeof handler === 'function' ? handler : handler.enter;
}
function getExitFunction(handler: KeyHandler): KeyFunction | undefined;
function getExitFunction(handler: NodeHandler): NodeFunction | undefined;
function getExitFunction(
handler: NodeHandler | KeyHandler
): NodeFunction | KeyFunction | undefined {
return typeof handler !== 'function' ? handler.exit : undefined;
}
function getKeyHandler(handler: NodeHandler, key: ChildKey): KeyHandler | undefined {
let keyVisitor = typeof handler !== 'function' ? handler.keys : undefined;
if (keyVisitor === undefined) return;
let keyHandler = keyVisitor[key];
if (keyHandler !== undefined) {
// widen specific key to all keys
return keyHandler as KeyHandler;
}
return keyVisitor.All;
}
function getNodeHandler(visitor: NodeVisitor, nodeType: NodeType): NodeHandler | undefined {
let handler = visitor[nodeType];
if (handler !== undefined) {
// widen specific Node to all nodes
return handler as NodeHandler;
}
return visitor.All;
}
function visitNode(visitor: NodeVisitor, node: Node): Node | Node[] | undefined | null | void {
let handler = getNodeHandler(visitor, node.type);
let enter: NodeFunction | undefined;
let exit: NodeFunction | undefined;
if (handler !== undefined) {
enter = getEnterFunction(handler);
exit = getExitFunction(handler);
}
let result: Node | Node[] | undefined | null | void;
if (enter !== undefined) {
result = enter(node);
}
if (result !== undefined && result !== null) {
if (JSON.stringify(node) === JSON.stringify(result)) {
result = undefined;
} else if (Array.isArray(result)) {
return visitArray(visitor, result) || result;
} else {
return visitNode(visitor, result) || result;
}
}
if (result === undefined) {
let keys = visitorKeys[node.type];
for (let i = 0; i < keys.length; i++) {
// we know if it has child keys we can widen to a ParentNode
visitKey(visitor, handler, node as ParentNode, keys[i]);
}
if (exit !== undefined) {
result = exit(node);
}
}
return result;
}
function visitKey(
visitor: NodeVisitor,
handler: NodeHandler | undefined,
node: ParentNode,
key: ChildKey
) {
let value = node[key] as Node | Node[] | null | undefined;
if (!value) {
return;
}
let keyEnter: KeyFunction | undefined;
let keyExit: KeyFunction | undefined;
if (handler !== undefined) {
let keyHandler = getKeyHandler(handler, key);
if (keyHandler !== undefined) {
keyEnter = getEnterFunction(keyHandler);
keyExit = getExitFunction(keyHandler);
}
}
if (keyEnter !== undefined) {
if (keyEnter(node, key) !== undefined) {
throw cannotReplaceOrRemoveInKeyHandlerYet(node, key);
}
}
if (Array.isArray(value)) {
visitArray(visitor, value);
} else {
let result = visitNode(visitor, value);
if (result !== undefined) {
assignKey(node, key, result);
}
}
if (keyExit !== undefined) {
if (keyExit(node, key) !== undefined) {
throw cannotReplaceOrRemoveInKeyHandlerYet(node, key);
}
}
}
function visitArray(visitor: NodeVisitor, array: Node[]) {
for (let i = 0; i < array.length; i++) {
let result = visitNode(visitor, array[i]);
if (result !== undefined) {
i += spliceArray(array, i, result) - 1;
}
}
}
function assignKey(node: Node, key: ChildKey, result: Node | Node[] | null) {
if (result === null) {
throw cannotRemoveNode(node[key], node, key);
} else if (Array.isArray(result)) {
if (result.length === 1) {
node[key] = result[0];
} else {
if (result.length === 0) {
throw cannotRemoveNode(node[key], node, key);
} else {
throw cannotReplaceNode(node[key], node, key);
}
}
} else {
node[key] = result;
}
}
function spliceArray(array: Node[], index: number, result: Node | Node[] | null) {
if (result === null) {
array.splice(index, 1);
return 0;
} else if (Array.isArray(result)) {
array.splice(index, 1, ...result);
return result.length;
} else {
array.splice(index, 1, result);
return 1;
}
}
export default function traverse(node: Node, visitor: NodeVisitor) {
visitNode(visitor, node);
}
|
|
|
|
|
16b7512b11bf197d8a97456fb0175e50565b85ad
|
|
|
|
|
|
fbc14dd4ef10b237a322dd54763d25f160f4aa82
|
|
|
|
|
|
|
fbc14dd4ef10b237a322dd54763d25f160f4aa82
|
|
|
|
|
|
|
fbc14dd4ef10b237a322dd54763d25f160f4aa82
|
|
|
|
|
import {
VirtualNodeAction,
VirtualNode,
Node,
VirtualNodeActionTypes,
Port,
ElementType,
} from 'core/types';
import { isVirtualPort } from 'core/utilities';
import { PortSet } from 'core/portset';
import { VirtualPort } from 'core/virtual-port';
/**
* Record the actions taking place on VirtualNode.
* @internal
*/
export class VirtualNodeActionQueue {
public queue: VirtualNodeAction[] = [];
public add(action: VirtualNodeAction): void {
this.queue.push(action);
}
public shift(): VirtualNodeAction | undefined {
return this.queue.shift();
}
public clear(): VirtualNodeAction[] {
const result = this.queue;
this.queue = [];
return result;
}
public replaceVirtualNodeWithRealNode(
virtualNode: VirtualNode,
realNode: Node,
doActionsIfPossible = true,
): void {
const len = this.queue.length;
for (let i = 0; i < len; ++i) {
const action = this.queue[i];
switch (action.type) {
case VirtualNodeActionTypes.PipeAction:
if (action.from.node === virtualNode) {
action.from = realNode.ports.get(action.from.name);
}
if (action.to.node === virtualNode) {
action.to = realNode.ports.get(action.to.name);
}
if (
doActionsIfPossible &&
!isVirtualPort(action.from) &&
!isVirtualPort(action.to)
) {
this.doAction(action);
this.queue.splice(i, 1);
}
break;
}
}
}
public doAction(action: VirtualNodeAction): void {
switch (action.type) {
case VirtualNodeActionTypes.PipeAction:
(action.from as Port).pipe(action.to as Port);
break;
}
}
}
export const virtualNodeActionQueue = new VirtualNodeActionQueue();
export class NextNode implements VirtualNode {
public readonly type = ElementType.VirtualNode;
public readonly brand = 'NextNode';
public readonly ports: PortSet<VirtualPort> = new PortSet<VirtualPort>(
VirtualPort,
false,
this,
);
}
|
|
|
|
|
b2de089e75f188f3482c29fc33bcbb7a91997599
|
|
|
|
|
chunyuyuan/NEWS_2019_network-master
|
0eec84b383156c82fbd64d900dce578700575d99
|
|
|
|
|
|
chunyuyuan/NEWS_2019_network-master
|
0eec84b383156c82fbd64d900dce578700575d99
|
|
|
|
|
|
chunyuyuan/NEWS_2019_network-master
|
0eec84b383156c82fbd64d900dce578700575d99
|
|
|
|
|
from flask import Flask, request, render_template, send_file, Response
import io
import base64
import csv
import json
import time
from collections import OrderedDict
import numpy
import pandas as pd
from numpy import genfromtxt
from flask import jsonify
from flask_cors import CORS
from LoadingNetwork import EchoWebSocket
import shutil
import gc
from tornado.wsgi import WSGIContainer
from tornado.web import Application, FallbackHandler
from tornado.websocket import WebSocketHandler
from tornado.ioloop import IOLoop
app = Flask('flasknado')
#app = Flask(__name__)
app.debug = True
CORS(app)
##initial netwrok csv data############################
rawdata = open('NetworkWithDistance.txt')
with open('NetworkWithDistance.txt') as f:
rawdata = f.readlines()
# you may also want to remove whitespace characters like `\n` at the end
# of each line
rawdata = [x.strip() for x in rawdata]
my_data = genfromtxt('networkwithdist.csv', delimiter=',')
# my_data=numpy.delete(my_data,(0),axis=0)
header = ['id', 'id_to', 'lon', 'lat', 'basinid']
frame = pd.DataFrame(my_data, columns=header)
data = []
MY_GLOBAL = []
with open('tempcsv.csv') as f:
for line in f:
temp = line.strip().split(',')
data.append(temp)
#############################
data1 = []
with open('MyFile1.txt') as f:
r = 0
for line in f:
if(r > 0):
data2 = []
# print(line)
temp = line.split("\",")
data2.append(temp[0][1:])
temp1 = temp[1].split(",[")
data2.append(temp1[0])
data2.append(temp1[1][:-2])
data1.append(data2)
r += 1
header = ['celllist', 'cellid', 'cellto']
frame_celllist = pd.DataFrame(data1, columns=header)
frame_celllist = frame_celllist.drop_duplicates()
del data1[:]
##################
data_c = []
with open('powerplant_cell_loc.csv') as f:
r = 0
for line in f:
if(r > 0):
data_cc = line.split(",")
data_c.append(data_cc)
# print(line)
r += 1
header = ['cellid', 'loc']
frame_cell = pd.DataFrame(data_c, columns=header)
frame_cell = frame_cell.drop_duplicates()
del data_c[:]
########################################################
import os
import sys
from SimpleHTTPServer import SimpleHTTPRequestHandler
import BaseHTTPServer
# class MyHTTPRequestHandler(SimpleHTTPRequestHandler):
# def translate_path(self,path):
# path = SimpleHTTPRequestHandler.translate_path(self,path)
# if os.path.isdir(path):
# for base in "index", "default":
# for ext in ".html", ".htm", ".txt":
# index = path + "/" + base + ext
# if os.path.exists(index):
# return index
# return path
# def test(HandlerClass = MyHTTPRequestHandler,
# ServerClass = BaseHTTPServer.HTTPServer):
# BaseHTTPServer.test(HandlerClass, ServerClass)
##################travesal network upstream############
'''def find_upstream(value):
gc.collect()
ii=0
li = []
temp=[]
a=frame.ix[int(value)]
temp.append(a)
#print(MY_GLOBAL)
MY_GLOBAL[:]=[]
#x=data[int(value)]
#x=frame[frame['id']==a['id_to']]
#print x
i=0
z=0
zz=0
while zz<len(temp):
item=temp[zz]
zz+=1
##print(z,len(temp))
## item=temp.pop()
## print item
#x=frame[frame['id_to']==item['id']]
x=data[int(float(item['id']))]
#print x
i=1
while i<len(x) :
# d = OrderedDict()
# xx=x.loc[x.index[i]]
xx=frame.ix[int(float(x[i]))]
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
i+=1
# ii+=1
##if ii%1000==0:
## print ii
temp.append(xx)
print(len(temp))
while z<len(temp):
item=temp[z]
z+=1
##print(z,len(temp))
## item=temp.pop()
## print item
#x=frame[frame['id_to']==item['id']]
x=data[int(float(item['id']))]
#print x
i=1
while i<len(x) :
d = OrderedDict()
#xx=x.loc[x.index[i]]
xx=frame.ix[int(float(x[i]))]
d['type'] = 'Feature'
d['geometry'] = {
'type': 'MultiLineString',
'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
}
d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
}
li.append(d)
d = OrderedDict()
#xx=x.loc[x.index[i]]
# xx=frame.ix[int(float(x[i]))]
i+=1
ii+=1
if ii%1000==0 or (ii+1)/len(temp)==1:
MY_GLOBAL.append((int)((ii+1)/(len(temp)* 1.0)*100))
## print(checkInt,ii,len(temp))
## print ii
# temp.append(xx)
#d = OrderedDict()
#d['type'] = 'FeatureCollection'
#d['features'] = li
#print li
print(ii)
return li,200'''
def find_upstream(value):
gc.collect()
ii = 0
li = []
temp = []
a = frame.ix[int(value)]
temp.append(int(value))
MY_GLOBAL[:] = []
i = 0
z = 0
zz = 0
jstring = ''
while z < len(temp):
item = frame.ix[temp[z]]
z += 1
x = data[int(float(item['id']))]
#print x
i = 1
while i < len(x):
xx = frame.ix[int(float(x[i]))]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
ii += 1
temp.append(int(float(x[i])))
i += 1
if ii % 1000 == 0:
# print(ii)
MY_GLOBAL.append((int)((ii + 1) / (200000 * 1.0) * 100))
# print(checkInt,ii,len(temp))
## print ii
# temp.append(xx)
#d = OrderedDict()
#d['type'] = 'FeatureCollection'
#d['features'] = li
#print li
# print(jstring)
MY_GLOBAL.append(100)
return jstring[:-1], 200
##################travesal network downstream############
def find_downstream(value, sourceid):
#print value,sourceid
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value)]
temp.append(a)
check = True
z = 0
while z < len(temp) and check:
item = temp[z]
z += 1
if(item['id_to'] == sourceid):
check = False
# break
## print item
# if(item['id']==sourceid):
# check=False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
# d=OrderedDict()
i += 1
ii += 1
temp.append(xx)
# if(item['id']==sourceid):
# check=False
# MY_GLOBAL.append(100)
# d = OrderedDict()
# d['type'] = 'FeatureCollection'
# d['features'] = li
# print li
# if (check==False):
return jstring[:-1], 200
##################travesal network downstream############
def find_downstream1(value):
#print value,sourceid
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value)]
temp.append(a)
check = True
z = 0
while z < len(temp) and check:
item = temp[z]
z += 1
## print item
# if(item['id']==sourceid):
# check=False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
# d=OrderedDict()
i += 1
ii += 1
temp.append(xx)
# if(item['id']==sourceid):
# check=False
# MY_GLOBAL.append(100)
# d = OrderedDict()
# d['type'] = 'FeatureCollection'
# d['features'] = li
# print li
# if (check==False):
return jstring[:-1], 200
#######################pp upstream#######################
def find_upstream_pp(cellid):
gc.collect()
# header=['celllist','cellid','cellto']
# header=['cellid','loc']
templi = frame_celllist[frame_celllist['cellid']
== cellid]['celllist'].tolist()
templist = templi[0][1:-1].split(",")
z = 0
jstring = ''
while z < len(templist):
curid = templist[z].strip()
# print(curid,templist)
curidloc = frame_cell[frame_cell['cellid'] == curid]['loc'].tolist()
curidloc1 = curidloc[0].split("_")
# print(curidloc1[0],curidloc1[1][:-1],curidloc[0])
z += 1
temp = frame_celllist[frame_celllist['cellid']
== curid]['cellto'].tolist()
print(temp)
temp = temp[0].split(",")
if len(temp) == 1 and temp[0][:-1] == "none":
# print(temp[0])
continue
else:
zz = 0
while zz < len(temp):
# print(temp[zz],temp)
x = temp[zz]
zz += 1
if zz == len(temp):
nextloc = frame_cell[frame_cell['cellid']
== x[:-1]]['loc'].tolist()
else:
nextloc = frame_cell[frame_cell['cellid']
== x]['loc'].tolist()
nextloc1 = nextloc[0].split("_")
# print(nextloc1[0],nextloc1[1][:-1],nextloc1)
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(curidloc1[0]) + ',' + str(curidloc1[1][:-1]) + '],[' + str(
nextloc1[0]) + ',' + str(nextloc1[1][:-1]) + ']]]},"properties": {"lat":' + str(curidloc1[1][:-1]) + ',"lon": ' + str(curidloc1[0]) + '}},'
# jstring+='{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[['+str(float(xx['lon']))+','+str(float(xx['lat']))+'],['+str(float(item['lon']))+','+str(float(item['lat']))+']]]},"properties": {"id_to": '+str(int(xx['id_to']))+',"id":'+str(int(xx['id']))+',"lat":'+str(float(xx['lat']))+',"lon": '+str(float(xx['lon']))+'}},';
return jstring[:-1], 200
#######################pp downstream#######################
def find_downstream_pp(cellid, dcellid):
gc.collect()
# header=['celllist','cellid','cellto']
# header=['cellid','loc']
print(cellid, dcellid)
templi = frame_celllist[frame_celllist['cellid']
== cellid]['celllist'].tolist()
templist = templi[0][1:-1].split(",")
z = len(templist) - 1
jstring = ''
while z > 0:
print(templist[z].strip())
curid = templist[z].strip()
if curid != str(dcellid):
z -= 1
else:
print(z)
break
while z > 0:
curid = templist[z].strip()
# print(curid,templist)
curidloc = frame_cell[frame_cell['cellid'] == curid]['loc'].tolist()
curidloc1 = curidloc[0].split("_")
# print(curidloc1[0],curidloc1[1][:-1],curidloc[0])
temp = frame_celllist[frame_celllist['cellid']
== templist[z].strip()]['cellto'].tolist()
z -= 1
print(temp)
temp = temp[0].split(",")
if len(temp) == 1 and temp[0][:-1] == "none":
# print(temp[0])
z -= 1
continue
else:
zz = 0
aaaa = 'false'
while zz < len(temp):
# print(temp[zz],temp)
x = temp[zz]
zz += 1
if zz == len(temp):
if x[:-1] == curid:
aaaa = 'true'
nextloc = frame_cell[frame_cell['cellid']
== x[:-1]]['loc'].tolist()
else:
if x == curid:
aaaa = 'true'
nextloc = frame_cell[frame_cell['cellid']
== x]['loc'].tolist()
if aaaa == 'true':
nextloc1 = nextloc[0].split("_")
# print(nextloc1[0],nextloc1[1][:-1],nextloc1)
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(curidloc1[0]) + ',' + str(curidloc1[1][:-1]) + '],[' + str(
nextloc1[0]) + ',' + str(nextloc1[1][:-1]) + ']]]},"properties": {"lat":' + str(curidloc1[1][:-1]) + ',"lon": ' + str(curidloc1[0]) + '}},'
# jstring+='{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[['+str(float(xx['lon']))+','+str(float(xx['lat']))+'],['+str(float(item['lon']))+','+str(float(item['lat']))+']]]},"properties": {"id_to": '+str(int(xx['id_to']))+',"id":'+str(int(xx['id']))+',"lat":'+str(float(xx['lat']))+',"lon": '+str(float(xx['lon']))+'}},';
print(jstring)
if len(jstring) > 0:
return jstring[:-1], 200
else:
return jstring, 200
@app.route("/", methods=['GET', 'POST'])
def index():
print(request)
return render_template('test1.html')
@app.route("/api/", methods=['GET', 'POST'])
def update():
print(request.method)
if request.method == "POST":
source = request.form["source"]
dist = request.form["dist"]
pic = request.form["pic"]
downfirst = request.form["downfirst"]
pp = request.form["pp"]
print(pp, source, dist, downfirst, pic)
if(pp == 'yes'):
upstream = request.form["upstream"]
if(upstream == 'yes'):
ucellid = request.form["ucellid"]
re, ii = find_upstream_pp(ucellid)
# print(re)
return json.dumps(re), ii
# if(upstream=='no'):
### ucellid = request.form["ucellid"]
# dcellid = request.form["dcellid"]
# re,ii=find_downstream_pp(ucellid,dcellid)
# print(re)
# if(pp=='no'):
source = request.form["source"]
dist = request.form["dist"]
pic = request.form["pic"]
downfirst = request.form["downfirst"]
#print dist
if(downfirst == 'no'):
if(source == 'yes'):
sourceid = request.form["sourceid"]
#print sourceid
import time
start = time. time()
re, ii = find_upstream(sourceid)
end = time. time()
#print ii,(end-start)
# print(re)
# print(MY_GLOBAL)
return json.dumps(re), ii
if(dist == 'yes'):
distid = request.form["distid"]
sourceid = request.form["sourceid"]
MY_GLOBAL[:] = []
#print distid,sourceid
re, ii = find_downstream(int(distid), int(sourceid))
print (re)
gc.collect()
MY_GLOBAL.append(100)
return json.dumps(re, sort_keys=False, indent=4), ii
if(downfirst == 'yes'):
if(dist == 'yes'):
distid = request.form["distid"]
sourceid = request.form["sourceid"]
MY_GLOBAL[:] = []
#print distid,sourceid
re, ii = find_downstream1(int(distid))
print (re)
gc.collect()
MY_GLOBAL.append(100)
return json.dumps(re, sort_keys=False, indent=4), ii
if(pic == 'yes'):
#print request.form
MY_GLOBAL[:] = []
start1 = request.form["dist_lat"]
start2 = request.form["dist_lon"]
goal1 = request.form["source_lat"]
goal2 = request.form["source_lon"]
fromdate = request.form["from"]
todate = request.form["to"]
import time
before = time.time()
output, str1, str2, str3 = LoadingNetwork.main(
[start1, start2], [goal1, goal2], fromdate, todate, rawdata)
#print str1,str2,str3
after = time.time()
print ("time,", after - before)
if(isinstance(output, str)):
return output, 201
else:
# gc.collect()
#print base64.b64encode(output.getvalue())
return base64.b64encode(
output.getvalue()) + "***" + str1 + "***" + str2 + "***" + str3, 200
class WebSocket(WebSocketHandler):
def on_message(self, message):
# self.write_message("Received: " + message)
# self.write_message("Received2: " + message)
# m=message.split("&")
print("Received message: " + m[0])
print("Received message: " + m[1])
print("Received message: " + m[2])
print("Received message: " + m[3])
print("Received message: " + m[4])
print("Received message: " + m[5])
print("Received message: " + m[6])
m=message[1:-1].split("&")
source = m[0].split("=")[1]
value = m[1].split("=")[1]
dist = m[2].split("=")[1]
value1 = m[3].split("=")[1]
pic = m[4].split("=")[1]
downfirst = m[5].split("=")[1]
pp = m[6].split("=")
print(pp, source, dist, downfirst, pic,value,value1)
###################################upstram##########################3
if(downfirst == 'no'):
if(source == 'yes'):
##################
gc.collect()
ii = 0
li = []
temp = []
a = frame.ix[int(value)]
temp.append(int(value))
i = 0
z = 0
zz = 0
jstring = ''
while z < len(temp):
item = frame.ix[temp[z]]
z += 1
x = data[int(float(item['id']))]
#print x
i = 1
while i < len(x):
xx = frame.ix[int(float(x[i]))]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
ii += 1
temp.append(int(float(x[i])))
i += 1
if(len(jstring)>1500000):
zz+=5
self.write_message( jstring[:-1])
self.write_message( '~'+str(zz*1.0/100))
jstring = ''
self.write_message( jstring[:-1])
self.write_message( '~1')
############################downstream#########################
if(dist == 'yes'):
########################################################################
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value1)]
temp.append(a)
check = True
z = 0
zz=0
while z < len(temp) and check:
item = temp[z]
z += 1
if(item['id_to'] == int(value)):
check = False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
i += 1
ii += 1
temp.append(xx)
if(len(jstring)>150000):
zz+=5
self.write_message( jstring[:-1])
self.write_message( '~'+str(zz*1.0/100))
jstring = ''
self.write_message( jstring[:-1])
self.write_message( '~1')
##########################downfirst##############################################
if(downfirst == 'yes'):
if(dist == 'yes'):
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value1)]
temp.append(a)
z = 0
zz=0
while z < len(temp) :
item = temp[z]
z += 1
# break
## print item
# if(item['id']==sourceid):
# check=False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
# d=OrderedDict()
i += 1
ii += 1
temp.append(xx)
# if(item['id']==sourceid):
# check=False
# MY_GLOBAL.append(100)
# d = OrderedDict()
# d['type'] = 'FeatureCollection'
# d['features'] = li
# print li
# if (check==False):
if(len(jstring)>150000):
zz+=5
self.write_message( jstring[:-1])
self.write_message( '~'+str(zz*1.0/100))
jstring = ''
self.write_message( jstring[:-1])
self.write_message( '~1')
# if(downfirst == 'yes'):
if(pic == 'yes'):
#print request.form
#"&dist_lat="+dist_lat+"&dist_lon="+dist_lon+"&source_lat="+source_lat+"&source_lon="+source_lon+"&from="+value3.value+"&to="+value4.value);
#m[6].split("=")
# start1 = request.form["dist_lat"]
# start2 = request.form["dist_lon"]
# goal1 = request.form["source_lat"]
# goal2 = request.form["source_lon"]
# fromdate = request.form["from"]
# todate = request.form["to"]
start1 = m[7].split("=")[1]
start2 = m[8].split("=")[1]
goal1 =m[9].split("=")[1]
goal2 = m[10].split("=")[1]
fromdate = m[11].split("=")[1]
todate = m[12].split("=")[1]
print(start1,start2,goal1,goal2,fromdate,todate)
import time
before = time.time()
output, str1, str2, str3 = LoadingNetwork.main(
[start1, start2], [goal1, goal2], fromdate, todate, rawdata)
#print str1,str2,str3
# print(output)
after = time.time()
print ("time,", after - before)
# if(isinstance(output, str)):
# return output, 201
# else:
# gc.collect()
#print base64.b64encode(output.getvalue())
# return base64.b64encode(
# output.getvalue()) + "***" + str1 + "***" + str2 + "***" + str3, 200
#
if __name__ == "__main__":
container = WSGIContainer(app)
server = Application([
(r'/websocket/', WebSocket),
(r'/we/', EchoWebSocket),
(r'.*', FallbackHandler, dict(fallback=container))
])
server.listen(5000)
IOLoop.instance().start()
# test()
|
|
|
|
|
437bedebb256fe41023d70a8b4d2313d4a24d111
|
|
|
|
|
|
9a64fa84fea1eb741368be5875aea096f59ce32a
|
|
|
|
|
|
|
9a64fa84fea1eb741368be5875aea096f59ce32a
|
|
|
|
|
|
|
9a64fa84fea1eb741368be5875aea096f59ce32a
|
|
|
|
|
package service
import (
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"net/http"
"reflect"
"strconv"
"strings"
"sync"
"time"
res "github.com/jirenius/go-res"
"github.com/jirenius/timerqueue"
)
type endpoint struct {
s *Service
url string
urlParams []string
refreshCount int
cachedURLs map[string]*cachedResponse
access res.AccessHandler
timeout time.Duration
group string
resetPatterns []string
tq *timerqueue.Queue
mu sync.RWMutex
node
}
type cachedResponse struct {
reloads int
reqParams map[string]string
crs map[string]cachedResource
rerr *res.Error
}
type cachedResource struct {
typ resourceType
model map[string]interface{}
collection []interface{}
}
type resourceType byte
const defaultRefreshDuration = time.Second * 3
const (
resourceTypeUnset resourceType = iota
resourceTypeModel
resourceTypeCollection
)
func newEndpoint(s *Service, cep *EndpointCfg) (*endpoint, error) {
if cep.URL == "" {
return nil, errors.New("missing url")
}
if cep.Pattern == "" {
return nil, errors.New("missing pattern")
}
urlParams, err := urlParams(cep.URL)
if err != nil {
return nil, err
}
ep := &endpoint{
s: s,
url: cep.URL,
urlParams: urlParams,
refreshCount: cep.RefreshCount,
cachedURLs: make(map[string]*cachedResponse),
access: cep.Access,
timeout: time.Millisecond * time.Duration(cep.Timeout),
}
ep.tq = timerqueue.New(ep.handleRefresh, time.Millisecond*time.Duration(cep.RefreshTime))
return ep, nil
}
func (ep *endpoint) handler() res.Handler {
return res.Handler{
Access: ep.access,
GetResource: ep.getResource,
Group: ep.url,
}
}
func (ep *endpoint) handleRefresh(i interface{}) {
ep.s.Debugf("Refreshing %s", i)
url := i.(string)
// Check if url is cached
ep.mu.RLock()
cresp, ok := ep.cachedURLs[url]
ep.mu.RUnlock()
if !ok {
ep.s.Logf("Url %s not found in cache on refresh", url)
return
}
params := cresp.reqParams
ep.s.res.WithGroup(url, func(s *res.Service) {
cresp.reloads++
if cresp.rerr != nil || cresp.reloads > ep.refreshCount {
// Reset resources
ep.mu.Lock()
delete(ep.cachedURLs, url)
ep.mu.Unlock()
resetResources := make([]string, len(ep.resetPatterns))
for i, rp := range ep.resetPatterns {
for _, param := range ep.urlParams {
rp = strings.Replace(rp, "${"+param+"}", params[param], 1)
}
resetResources[i] = rp
}
ep.s.res.Reset(resetResources, nil)
return
}
defer ep.tq.Add(i)
ncresp := ep.getURL(url, params)
if ncresp.rerr != nil {
ep.s.Logf("Error refreshing url %s:\n\t%s", url, ncresp.rerr.Message)
return
}
for rid, nv := range ncresp.crs {
v, ok := cresp.crs[rid]
if ok {
r, err := ep.s.res.Resource(rid)
if err != nil {
// This shouldn't be possible. Let's panic.
panic(fmt.Sprintf("error getting res resource %s:\n\t%s", rid, err))
}
updateResource(v, nv, r)
delete(cresp.crs, rid)
}
}
// for rid := range cresp.crs {
// r, err := ep.s.res.Resource(rid)
// r.DeleteEvent()
// }
// Replacing the old cachedResources with the new ones
cresp.crs = ncresp.crs
})
}
func updateResource(v, nv cachedResource, r res.Resource) {
switch v.typ {
case resourceTypeModel:
updateModel(v.model, nv.model, r)
case resourceTypeCollection:
updateCollection(v.collection, nv.collection, r)
}
}
func updateModel(a, b map[string]interface{}, r res.Resource) {
ch := make(map[string]interface{})
for k := range a {
if _, ok := b[k]; !ok {
ch[k] = res.DeleteAction
}
}
for k, v := range b {
ov, ok := a[k]
if !(ok && reflect.DeepEqual(v, ov)) {
ch[k] = v
}
}
r.ChangeEvent(ch)
}
func updateCollection(a, b []interface{}, r res.Resource) {
var i, j int
// Do a LCS matric calculation
// https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
s := 0
m := len(a)
n := len(b)
// Trim of matches at the start and end
for s < m && s < n && reflect.DeepEqual(a[s], b[s]) {
s++
}
if s == m && s == n {
return
}
for s < m && s < n && reflect.DeepEqual(a[m-1], b[n-1]) {
m--
n--
}
var aa, bb []interface{}
if s > 0 || m < len(a) {
aa = a[s:m]
m = m - s
} else {
aa = a
}
if s > 0 || n < len(b) {
bb = b[s:n]
n = n - s
} else {
bb = b
}
// Create matrix and initialize it
w := m + 1
c := make([]int, w*(n+1))
for i = 0; i < m; i++ {
for j = 0; j < n; j++ {
if reflect.DeepEqual(aa[i], bb[j]) {
c[(i+1)+w*(j+1)] = c[i+w*j] + 1
} else {
v1 := c[(i+1)+w*j]
v2 := c[i+w*(j+1)]
if v2 > v1 {
c[(i+1)+w*(j+1)] = v2
} else {
c[(i+1)+w*(j+1)] = v1
}
}
}
}
idx := m + s
i = m
j = n
rm := 0
var adds [][3]int
addCount := n - c[w*(n+1)-1]
if addCount > 0 {
adds = make([][3]int, 0, addCount)
}
Loop:
for {
m = i - 1
n = j - 1
switch {
case i > 0 && j > 0 && reflect.DeepEqual(aa[m], bb[n]):
idx--
i--
j--
case j > 0 && (i == 0 || c[i+w*n] >= c[m+w*j]):
adds = append(adds, [3]int{n, idx, rm})
j--
case i > 0 && (j == 0 || c[i+w*n] < c[m+w*j]):
idx--
r.RemoveEvent(idx)
rm++
i--
default:
break Loop
}
}
// Do the adds
l := len(adds) - 1
for i := l; i >= 0; i-- {
add := adds[i]
r.AddEvent(bb[add[0]], add[1]-rm+add[2]+l-i)
}
}
func (ep *endpoint) getResource(r res.GetRequest) {
// Replace param placeholders
url := ep.url
for _, param := range ep.urlParams {
url = strings.Replace(url, "${"+param+"}", r.PathParam(param), 1)
}
// Check if url is cached
ep.mu.RLock()
cresp, ok := ep.cachedURLs[url]
ep.mu.RUnlock()
if !ok {
if ep.timeout > 0 {
r.Timeout(ep.timeout)
}
cresp = ep.cacheURL(url, r.PathParams())
}
// Return any encountered error when getting the endpoint
if cresp.rerr != nil {
r.Error(cresp.rerr)
return
}
// Check if resource exists
cr, ok := cresp.crs[r.ResourceName()]
if !ok {
r.NotFound()
return
}
switch cr.typ {
case resourceTypeModel:
r.Model(cr.model)
case resourceTypeCollection:
r.Collection(cr.collection)
}
}
func (ep *endpoint) cacheURL(url string, reqParams map[string]string) *cachedResponse {
cresp := ep.getURL(url, reqParams)
ep.mu.Lock()
ep.cachedURLs[url] = cresp
ep.mu.Unlock()
ep.tq.Add(url)
return cresp
}
func (ep *endpoint) getURL(url string, reqParams map[string]string) *cachedResponse {
cr := cachedResponse{reqParams: reqParams}
// Make HTTP request
resp, err := http.Get(url)
if err != nil {
ep.s.Debugf("Error fetching endpoint: %s\n\t%s", url, err)
cr.rerr = res.InternalError(err)
return &cr
}
defer resp.Body.Close()
// Handle non-2XX status codes
if resp.StatusCode == 404 {
cr.rerr = res.ErrNotFound
return &cr
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
cr.rerr = res.InternalError(fmt.Errorf("unexpected response code: %d", resp.StatusCode))
return &cr
}
// Read body
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
cr.rerr = res.InternalError(err)
return &cr
}
// Unmarshal body
var v value
if err = json.Unmarshal(body, &v); err != nil {
cr.rerr = res.InternalError(err)
return &cr
}
// Traverse the data
crs := make(map[string]cachedResource)
err = ep.traverse(crs, v, nil, reqParams)
if err != nil {
cr.rerr = res.InternalError(fmt.Errorf("invalid data structure for %s: %s", url, err))
return &cr
}
cr.crs = crs
return &cr
}
func (ep *endpoint) traverse(crs map[string]cachedResource, v value, path []string, reqParams map[string]string) error {
var err error
switch v.typ {
case valueTypeObject:
_, err = traverseModel(crs, v, path, &ep.node, reqParams, "")
case valueTypeArray:
_, err = traverseCollection(crs, v, path, &ep.node, reqParams, "")
default:
return errors.New("endpoint didn't respond with a json object or array")
}
if err != nil {
return err
}
return nil
}
func traverseModel(crs map[string]cachedResource, v value, path []string, n *node, reqParams map[string]string, pathPart string) (res.Ref, error) {
if n.typ != resourceTypeModel {
return "", fmt.Errorf("expected a model at %s", pathStr(path))
}
// Append path part
switch n.ptyp {
case pathTypeDefault:
path = append(path, pathPart)
case pathTypeProperty:
idv, ok := v.obj[n.idProp]
if !ok {
return "", fmt.Errorf("missing id property %s at:\n\t%s", n.idProp, pathStr(path))
}
switch idv.typ {
case valueTypeString:
var idstr string
err := json.Unmarshal(idv.raw, &idstr)
if err != nil {
return "", err
}
path = append(path, idstr)
case valueTypeNumber:
path = append(path, string(idv.raw))
default:
return "", fmt.Errorf("invalid id value for property %s at:\n\t%s", n.idProp, pathStr(path))
}
path = append(path)
}
model := make(map[string]interface{})
for k, kv := range v.obj {
// Get next node
next := n.nodes[k]
if next == nil {
next = n.param
}
switch kv.typ {
case valueTypeObject:
if next != nil {
ref, err := traverseModel(crs, kv, path, next, reqParams, k)
if err != nil {
return "", err
}
model[k] = ref
}
case valueTypeArray:
if next != nil {
ref, err := traverseCollection(crs, kv, path, next, reqParams, k)
if err != nil {
return "", err
}
model[k] = ref
}
default:
if next != nil {
return "", fmt.Errorf("unexpected primitive value for property %s at %s", k, pathStr(path))
}
model[k] = kv
}
}
// Create rid
p := make([]interface{}, len(n.params))
for j, pp := range n.params {
switch pp.typ {
case paramTypeURL:
p[j] = reqParams[pp.name]
case paramTypePath:
p[j] = path[pp.idx]
}
}
rid := fmt.Sprintf(n.pattern, p...)
crs[rid] = cachedResource{
typ: resourceTypeModel,
model: model,
}
return res.Ref(rid), nil
}
func traverseCollection(crs map[string]cachedResource, v value, path []string, n *node, reqParams map[string]string, pathPart string) (res.Ref, error) {
if n.typ != resourceTypeCollection {
return "", fmt.Errorf("expected a collection at %s", pathStr(path))
}
if n.ptyp != pathTypeRoot {
// Append path part
path = append(path, pathPart)
}
collection := make([]interface{}, len(v.arr))
for j, kv := range v.arr {
next := n.param
switch kv.typ {
case valueTypeObject:
if next != nil {
ref, err := traverseModel(crs, kv, path, next, reqParams, strconv.Itoa(j))
if err != nil {
return "", err
}
collection[j] = ref
}
case valueTypeArray:
if next != nil {
ref, err := traverseCollection(crs, kv, path, next, reqParams, strconv.Itoa(j))
if err != nil {
return "", err
}
collection[j] = ref
}
default:
if next != nil {
return "", fmt.Errorf("unexpected primitive value for element %d at %s", j, pathStr(path))
}
collection[j] = kv
}
}
// Create rid
p := make([]interface{}, len(n.params))
for k, pp := range n.params {
switch pp.typ {
case paramTypeURL:
p[k] = reqParams[pp.name]
case paramTypePath:
p[k] = path[pp.idx]
}
}
rid := fmt.Sprintf(n.pattern, p...)
crs[rid] = cachedResource{
typ: resourceTypeCollection,
collection: collection,
}
return res.Ref(rid), nil
}
func pathStr(path []string) string {
if len(path) == 0 {
return "endpoint root"
}
return strings.Join(path, ".")
}
|
|
|
|
|
77d7b261ad1febba3308206e114ebff010e09836
|
|
|
|
|
|
e9ee360de11c49109a45829cb85d4c21db270e22
|
|
|
|
|
|
|
e9ee360de11c49109a45829cb85d4c21db270e22
|
|
|
|
|
|
|
e9ee360de11c49109a45829cb85d4c21db270e22
|
|
|
|
|
// (c) Yasuhiro Fujii <http://mimosa-pudica.net>, under MIT License.
use std::*;
pub enum RegEx<'a, T, U: Copy = ()> {
Eps,
Atom( Box<dyn 'a + Fn( usize, &T ) -> bool> ),
Alt( Box<RegEx<'a, T, U>>, Box<RegEx<'a, T, U>> ),
Seq( Box<RegEx<'a, T, U>>, Box<RegEx<'a, T, U>>, usize ),
Repeat( Box<RegEx<'a, T, U>>, usize ),
Weight( isize ),
Mark( U ),
}
impl<'a, T, U: Copy> ops::Add for Box<RegEx<'a, T, U>> {
type Output = Box<RegEx<'a, T, U>>;
fn add( self, other: Self ) -> Self::Output {
Box::new( RegEx::Alt( self, other ) )
}
}
impl<'a, T, U: Copy> ops::Mul for Box<RegEx<'a, T, U>> {
type Output = Box<RegEx<'a, T, U>>;
fn mul( self, other: Self ) -> Self::Output {
Box::new( RegEx::Seq( self, other, usize::MAX ) )
}
}
pub fn eps<'a, T, U: Copy>() -> Box<RegEx<'a, T, U>> {
Box::new( RegEx::Eps )
}
pub fn atom<'a, T, U: Copy, F: 'a + Fn( usize, &T ) -> bool>( f: F ) -> Box<RegEx<'a, T, U>> {
Box::new( RegEx::Atom( Box::new( f ) ) )
}
pub fn rep<'a, T, U: Copy>( e0: Box<RegEx<'a, T, U>> ) -> Box<RegEx<'a, T, U>> {
Box::new( RegEx::Repeat( e0, usize::MAX ) )
}
pub fn weight<'a, T, U: Copy>( w: isize ) -> Box<RegEx<'a, T, U>> {
Box::new( RegEx::Weight( w ) )
}
pub fn mark<'a, T, U: Copy>( m: U ) -> Box<RegEx<'a, T, U>> {
Box::new( RegEx::Mark( m ) )
}
pub fn opt<'a, T, U: Copy>( e0: Box<RegEx<'a, T, U>> ) -> Box<RegEx<'a, T, U>> {
eps() + e0
}
pub fn any<'a, T, U: Copy>() -> Box<RegEx<'a, T, U>> {
atom( move |_, _| true )
}
pub fn val<'a, T: 'a + PartialEq, U: Copy>( v0: T ) -> Box<RegEx<'a, T, U>> {
atom( move |_, v| *v == v0 )
}
pub struct RegExRoot<'a, T, U: Copy = ()> {
regex: Box<RegEx<'a, T, U>>,
nstate: usize,
}
impl<'a, T, U: Copy> RegExRoot<'a, T, U> {
pub fn new( mut e: Box<RegEx<'a, T, U>> ) -> RegExRoot<'a, T, U> {
let n = Self::renumber( &mut e, 0 );
RegExRoot{
regex: e,
nstate: n,
}
}
fn renumber( e: &mut RegEx<'a, T, U>, i: usize ) -> usize {
match *e {
RegEx::Eps => i,
RegEx::Atom( _ ) => i,
RegEx::Alt( ref mut e0, ref mut e1 ) => {
Self::renumber( e1, Self::renumber( e0, i ) )
}
RegEx::Seq( ref mut e0, ref mut e1, ref mut s ) => {
*s = Self::renumber( e0, i );
Self::renumber( e1, *s + 1 )
}
RegEx::Repeat( ref mut e0, ref mut s ) => {
*s = i;
Self::renumber( e0, i + 1 )
}
RegEx::Weight( _ ) => i,
RegEx::Mark( _ ) => i,
}
}
}
struct Path<T>( usize, T, Option<rc::Rc<Path<T>>> );
#[derive( Clone )]
struct State<T>( isize, Option<rc::Rc<Path<T>>> );
#[derive( Clone )]
pub struct Matcher<'a, T, U: Copy = ()> {
root: &'a RegExRoot<'a, T, U>,
index: usize,
s0: State<U>,
states: Vec<State<U>>,
s1: State<U>,
}
impl<'a, T, U: Copy> Matcher<'a, T, U> {
pub fn new( root: &'a RegExRoot<'a, T, U> ) -> Matcher<'a, T, U> {
let mut this = Matcher{
root: root,
index: 0,
s0: State( 0, None ),
states: vec![ State( isize::MAX, None ); root.nstate ],
s1: State( isize::MAX, None ),
};
this.s1 = this.propagate( &root.regex, State( 0, None ) );
this
}
pub fn feed( &mut self, v: &T ) {
let s0 = mem::replace( &mut self.s0, State( isize::MAX, None ) );
let s1 = self.shift( &self.root.regex, v, s0 );
self.index += 1;
let s2 = self.propagate( &self.root.regex, State( isize::MAX, None ) );
self.s1 = Self::choice( s1, s2 );
}
pub fn feed_iter<'b, Iter: IntoIterator<Item = &'b T>>( &mut self, iter: Iter ) where 'a: 'b {
for v in iter {
self.feed( v );
}
}
pub fn is_match( &self ) -> bool {
self.s1.0 != isize::MAX
}
pub fn is_alive( &self ) -> bool {
self.s0.0 != isize::MAX ||
self.s1.0 != isize::MAX ||
self.states.iter().any( |s| s.0 != isize::MAX )
}
pub fn path( &self ) -> Vec<(usize, U)> {
let mut result = Vec::new();
let mut it = self.s1.1.clone();
while let Some( e ) = it {
result.push( (e.0, e.1) );
it = e.2.clone();
}
result.reverse();
result
}
fn choice( s0: State<U>, s1: State<U> ) -> State<U> {
if s1.0 < s0.0 { s1 } else { s0 }
}
fn choice_inplace( s0: &mut State<U>, s1: State<U> ) {
if s1.0 < s0.0 {
*s0 = s1;
}
}
// handle epsilon transition.
fn propagate( &mut self, e: &RegEx<'a, T, U>, s0: State<U> ) -> State<U> {
match *e {
RegEx::Eps => s0,
RegEx::Atom( _ ) => State( isize::MAX, None ),
RegEx::Alt( ref e0, ref e1 ) => {
let s1 = self.propagate( e0, s0.clone() );
let s2 = self.propagate( e1, s0 );
Self::choice( s1, s2 )
}
RegEx::Seq( ref e0, ref e1, s ) => {
let s1 = self.propagate( e0, s0 );
Self::choice_inplace( &mut self.states[s], s1 );
let s2 = self.states[s].clone();
self.propagate( e1, s2 )
}
RegEx::Repeat( ref e0, s ) => {
Self::choice_inplace( &mut self.states[s], s0 );
let s1 = self.states[s].clone();
let s2 = self.propagate( e0, s1 );
Self::choice_inplace( &mut self.states[s], s2 );
self.states[s].clone()
}
RegEx::Weight( w ) => {
let dw = if s0.0 != isize::MAX { w } else { 0 };
State( s0.0 + dw, s0.1 )
}
RegEx::Mark( m ) => {
State( s0.0, Some( rc::Rc::new( Path( self.index, m, s0.1 ) ) ) )
}
}
}
// handle normal transition.
fn shift( &mut self, e: &RegEx<'a, T, U>, v: &T, s0: State<U> ) -> State<U> {
match *e {
RegEx::Eps => State( isize::MAX, None ),
RegEx::Atom( ref f ) => {
if s0.0 != isize::MAX && f( self.index, v ) {
s0
}
else {
State( isize::MAX, None )
}
}
RegEx::Alt( ref e0, ref e1 ) => {
let s1 = self.shift( e0, v, s0.clone() );
let s2 = self.shift( e1, v, s0 );
Self::choice( s1, s2 )
}
RegEx::Seq( ref e0, ref e1, s ) => {
let s1 = self.shift( e0, v, s0 );
let s2 = mem::replace( &mut self.states[s], s1 );
self.shift( e1, v, s2 )
}
RegEx::Repeat( ref e0, s ) => {
let s1 = mem::replace( &mut self.states[s], State( isize::MAX, None ) );
self.states[s] = self.shift( e0, v, s1 );
State( isize::MAX, None )
}
RegEx::Weight( _ ) => State( isize::MAX, None ),
RegEx::Mark( _ ) => State( isize::MAX, None ),
}
}
}
|
|
|
|
|
e5243bcaf71ccb5aaa825244f3d85a3ec0bf22aa
|
|
|
|
|
|
849f40f8b6ad81a5472817688b702d15f916c477
|
|
|
|
|
|
|
849f40f8b6ad81a5472817688b702d15f916c477
|
|
|
|
|
|
|
849f40f8b6ad81a5472817688b702d15f916c477
|
|
|
|
|
import * as vscode from 'vscode';
interface Input {
load: () => void;
reset: () => void;
ready: (text: string) => Thenable<vscode.TextEditor>;
get: () => string;
getFilename: () => string;
};
let _input = '';
let _filename = '';
const load = () => {
const doc = vscode.window.activeTextEditor?.document;
_input = (doc ? doc.getText() : '').trim();
_filename = (doc ? doc.fileName : '').trim();
};
let editor$: null | Thenable<vscode.TextEditor> = null;
let _editor: null | vscode.TextEditor = null;
const reset = () => {
_input = '';
editor$ = null;
_editor = null;
};
const ready = (text: string): Thenable<vscode.TextEditor> => {
if (editor$ === null || (_editor !== null && _editor.document.isClosed)) {
_input = text;
editor$ = vscode.workspace.openTextDocument({ language: 'plaintext', content: '' }).then(doc => {
return vscode.window.showTextDocument(doc).then(editor => {
editor.edit(builder => {
builder.insert(doc.positionAt(0), text);
}).then(() => editor);
_editor = editor;
return editor;
});
});
return editor$;
} else if (_editor === null) {
return editor$.then(() => ready(text));
}
return editor$;
};
const get = (): string => {
return _input;
};
const getFilename = (): string => {
return _filename;
};
export const input: Input = {
load,
reset,
ready,
get,
getFilename,
};
|
|
|
|
|
9bd21b0a0645626b2270758effb332d3ec926934
|
|
|
|
api/controllers/expenseController.js
|
SebastianDochia/budget-app
|
7b03c3bf03866f30756eaa0dbf7669fc74767aac
|
|
|
|
|
api/controllers/expenseController.js
|
SebastianDochia/budget-app
|
7b03c3bf03866f30756eaa0dbf7669fc74767aac
|
|
|
|
|
api/controllers/expenseController.js
|
SebastianDochia/budget-app
|
7b03c3bf03866f30756eaa0dbf7669fc74767aac
|
|
|
|
|
'use strict';
const firebase = require('../db');
const Expense = require('../models/expense');
const firestore = firebase.firestore();
const addExpense = async (req, res, next) => {
try {
const data = req.body;
await firestore.collection('expenses').doc().set(data);
res.send('Expense saved successfuly');
} catch (error) {
res.status(400).send(error.message);
}
}
const getAllExpenses = async (req, res, next) => {
try {
const expenses = await firestore.collection('expenses');
const data = await expenses.get();
const expensesArray = [];
if(data.empty) {
res.status(404).send('No expense found');
}else {
data.forEach(doc => {
const expense = new Expense(
doc.id,
doc.data().body.name,
doc.data().body.value,
doc.data().body.date,
doc.data().body.category,
);
expensesArray.push(expense);
});
res.send(expensesArray);
}
} catch (error) {
res.status(400).send(error.message);
}
}
const getExpense = async (req, res, next) => {
try {
const id = req.params.id;
const expense = await firestore.collection('expense').doc(id);
const data = await expense.get();
if(!data.exists) {
res.status(404).send('Expense with the given ID not found');
}else {
res.send(data.data());
}
} catch (error) {
res.status(400).send(error.message);
}
}
const updateExpense = async (req, res, next) => {
try {
const id = req.params.id;
const data = req.body;
const expense = await firestore.collection('expenses').doc(id);
await expense.update(data);
res.send('Expense updated successfuly');
} catch (error) {
res.status(400).send(error.message);
}
}
const deleteExpense = async (req, res, next) => {
try {
const id = req.params.id;
await firestore.collection('expenses').doc(id).delete();
res.send('Expense deleted successfuly');
} catch (error) {
res.status(400).send(error.message);
}
}
module.exports = {
addExpense,
getAllExpenses,
getExpense,
updateExpense,
deleteExpense,
}
|
|
|
|
|
369fa64ebc77cae1df42bea6460e705c18ab2ee7
|
|
|
|
|
|
e7cacb4e36d4646b6ef086c1e634a8c314223744
|
|
|
|
|
|
|
e7cacb4e36d4646b6ef086c1e634a8c314223744
|
|
|
|
|
|
|
e7cacb4e36d4646b6ef086c1e634a8c314223744
|
|
|
|
|
use crate::chess::utils::calculate_squares_to_edge;
use crate::chess::{board::Edge, Board, Move, Piece};
pub const ROOK_MOVES: &[Move] = &[
Move {
x: 8,
y: 0,
constraints: &[],
},
Move {
x: 0,
y: 8,
constraints: &[],
},
];
pub fn generate_rook_moves(board: &Board, sq: usize, piece: &Piece) -> Vec<usize> {
let mut moves = vec![];
for mv in ROOK_MOVES.iter() {
if mv.x == 0 {
let top_edge = calculate_squares_to_edge(Edge::Top, sq);
let mut valid = true;
for i in 1..=top_edge {
if !valid {
continue;
}
let final_sq = sq + i as usize * 8;
match board.piece_at(final_sq) {
Some(p) => {
if p.side() != piece.side() {
moves.push(final_sq);
}
valid = false;
}
None => moves.push(final_sq),
};
}
let bottom_edge = calculate_squares_to_edge(Edge::Bottom, sq);
let mut valid = true;
for i in 1..=bottom_edge {
if !valid {
continue;
}
let final_sq = sq - i * 8;
match board.piece_at(final_sq) {
Some(p) => {
if p.side() != piece.side() {
moves.push(final_sq);
}
valid = false;
}
None => moves.push(final_sq),
}
}
} else {
let right_edge = calculate_squares_to_edge(Edge::Right, sq);
let mut valid = true;
for i in 1..=right_edge {
if !valid {
continue;
}
let final_sq = sq + i;
match board.piece_at(final_sq) {
Some(p) => {
if p.side() != piece.side() {
moves.push(final_sq);
}
valid = false;
}
None => moves.push(final_sq),
}
}
let left_edge = calculate_squares_to_edge(Edge::Left, sq);
let mut valid = true;
for i in 1..=left_edge {
if !valid {
continue;
}
let final_sq = sq - i;
match board.piece_at(final_sq) {
Some(p) => {
if p.side() != piece.side() {
moves.push(final_sq);
}
valid = false;
}
None => moves.push(final_sq),
}
}
}
}
moves
}
|
|
|
|
|
404cb8362bcfdd803cb1b26c1c5bdcf7eb8586c2
|
|
|
|
kotlin/src/test/kotlin/nonamedb/test/specs/unit/storage/engines/MemoryEngineSpec.kt
|
|
e229ea19df94a89ddd135cf9e2b5bce5f1aa0f6f
|
|
|
|
|
kotlin/src/test/kotlin/nonamedb/test/specs/unit/storage/engines/MemoryEngineSpec.kt
|
|
e229ea19df94a89ddd135cf9e2b5bce5f1aa0f6f
|
|
|
|
|
kotlin/src/test/kotlin/nonamedb/test/specs/unit/storage/engines/MemoryEngineSpec.kt
|
|
e229ea19df94a89ddd135cf9e2b5bce5f1aa0f6f
|
|
|
|
|
package nonamedb.test.specs.unit.storage.engines
import io.kotlintest.*
import io.kotlintest.specs.StringSpec
import nonamedb.storage.Done
import nonamedb.storage.engines.MemoryEngine
class MemoryEngineSpec : StringSpec(){
init {
val timeout = 5.seconds
val testKey = "some key"
val testValue = "some value".toByteArray()
val updatedTestValue = "some updated value".toByteArray()
val testEngine = MemoryEngine()
"should fail to retrieve missing data" {
val result = testEngine.get(testKey)
eventually(timeout) {
result.getCompleted() shouldBe null
}
}
"should successfully add data" {
val result = testEngine.put(testKey, testValue)
eventually(timeout) {
result.getCompleted() shouldBe Done
}
}
"should successfully retrieve data" {
val result = testEngine.get(testKey)
eventually(timeout) {
result.getCompleted() shouldBe testValue
}
}
"should successfully update data" {
val result = testEngine.put(testKey, updatedTestValue)
eventually(timeout) {
result.getCompleted() shouldBe Done
}
}
"should successfully retrieve updated data" {
val result = testEngine.get(testKey)
eventually(timeout) {
result.getCompleted() shouldBe updatedTestValue
}
}
"should successfully remove data" {
val result = testEngine.put(testKey, "".toByteArray())
eventually(timeout) {
result.getCompleted() shouldBe Done
}
}
"should fail to retrieve removed data" {
val result = testEngine.get(testKey)
eventually(timeout) {
result.getCompleted() shouldBe null
}
}
}
}
|
|
|
|
|
7f1610e61fe4d126e2a9d2e38f0b4661c65c9e03
|
|
|
|
|
|
16e54fa159f28802fadef1d0d5632d32b07c6f86
|
|
|
|
|
|
|
16e54fa159f28802fadef1d0d5632d32b07c6f86
|
|
|
|
|
|
|
16e54fa159f28802fadef1d0d5632d32b07c6f86
|
|
|
|
|
package cmdutil
import (
"sync"
"testing"
"github.com/stretchr/testify/assert"
)
// Test that a pool with a single worker finishes.
func TestPool1(t *testing.T) {
p := NewPool(1)
val := 0
p.Submit(func() {
val++
p.Done()
})
p.Finish()
assert.Equal(t, 1, val)
}
// Test that a pool with two workers executes them concurrently and finishes.
func TestPool2(t *testing.T) {
p := NewPool(2)
var mux1, mux2 sync.Mutex
val := 0
// Start with both mutexes locked. In sequence wait on one and unlock the other so that both
// functions must run concurrently to correctly unlock them.
mux1.Lock()
mux2.Lock()
p.Submit(func() {
// Wait on 1.
mux1.Lock()
val++
// Signal 2.
mux2.Unlock()
p.Done()
})
p.Submit(func() {
// Signal 1.
mux1.Unlock()
// Wait on 2.
mux2.Lock()
val++
p.Done()
})
// At the end both mutexes are again locked.
// Wait for completion and ensure both functions have updated the value.
p.Finish()
assert.Equal(t, 2, val)
}
|
|
|
|
|
9671d678b496b5bd1714a0e06a8fe25b3fbd9372
|
|
|
|
app/Http/Controllers/LabelsResourceController.php
|
|
4f2014121473ffe1a1f5929636b85272ff2ef421
|
|
|
|
|
app/Http/Controllers/LabelsResourceController.php
|
|
4f2014121473ffe1a1f5929636b85272ff2ef421
|
|
|
|
|
app/Http/Controllers/LabelsResourceController.php
|
|
4f2014121473ffe1a1f5929636b85272ff2ef421
|
|
|
|
|
<?php
namespace App\Http\Controllers;
use App\Traits\ViewSorter;
use App\Models\Label;
use App\Models\Task;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
class LabelsResourceController extends Controller
{
use ViewSorter;
/**
* Display a list of all labels
*
*/
public function index()
{
// Return labels view
return view('labels', [
'labels' => Label::query()->
with(['tasks'])->
where('user_id', '=', Auth::id())->
get()
]);
}
/**
* Store a new label in the database
*
* @param Request $request
*/
public function store(Request $request)
{
// Validate the request
$fields = $request->validateWithBag('new_label', [
'name' => 'required',
'color' => 'required',
]);
// Assign the user ID to the request
$fields['user_id'] = Auth::id();
// Create the label
Label::query()->create($fields);
// Redirect back
return redirect()->back();
}
/**
* Display the specified label
*
* @param Label $label
*/
public function show(Label $label)
{
// Return the single label view
return view('label-single', [
'label' => Label::query()->
where('user_id', '=', Auth::id())->
where('id', '=', $label->id)->
first(),
'tasks' => Task::query()->
where('user_id', '=', Auth::id())->
where('label_id', '=', $label->id)->
whereNull('completed')->
orderBy($this->getSorters()->sort_by, $this->getSorters()->order_by)->
get(),
]);
}
/**
* Update the specified resource in storage.
*
* @param Request $request
* @param Label $label
*/
public function update(Request $request, Label $label)
{
// Validate the request
$fields = $request->validateWithBag('edit_label_' . $label->id, [
'name' => 'required',
'color' => 'required',
]);
// Update the label
Label::query()->find($label->id)->update($fields);
// Redirect to index with success
return redirect()->back();
}
/**
* Remove the specified label from storage.
*
* @param Label $label
*/
public function destroy(Label $label)
{
// Find and delete existing label
Label::query()->find($label->id)->delete();
// Remove label from tasks
Task::query()->
where('label_id', '=', $label->id)->
update(['label_id' => null]);
// Redirect to index
return redirect()->back();
}
}
|
|
|
|
|
70dc725ccf32e9d60106d386ebd957e8de6b19cd
|
|
|
|
Array/wuchao/other/7-16 c实现string函数/StringUtils.c
|
JessonYue/LeetCodeLearning
|
3c22a4fcdfe8b47f9f64b939c8b27742c4e30b79
|
|
|
|
|
Array/wuchao/other/7-16 c实现string函数/StringUtils.c
|
JessonYue/LeetCodeLearning
|
3c22a4fcdfe8b47f9f64b939c8b27742c4e30b79
|
|
|
|
|
Array/wuchao/other/7-16 c实现string函数/StringUtils.c
|
JessonYue/LeetCodeLearning
|
3c22a4fcdfe8b47f9f64b939c8b27742c4e30b79
|
|
|
|
|
//
// Created by 吴超 on 2020/7/16.
//
#include <stdlib.h>
#include <stdio.h>
/**
* C语言实现strcpy（字符串复制）、strcat（字符串链接）、strstr（字符串包含）、strchr（字符出现位置）、memcpy（拷贝）
*/
char *strcpy(char *source);
char *strcat(char *dest, char *source);
int strstr(char *dest, char *source);
int strchr(char *source, char target);
void* memcpy(char *dest, char* source, size_t size);
size_t stringLen(char *source);
char *strcpy(char *source) {
char *dest = malloc(stringLen(source) * sizeof(char));
int i = 0;
while (source[i] != '\0') {
dest[i] = source[i];
i++;
}
return dest;
}
char *strcat(char *dest, char *source) {
int destLen = stringLen(dest);
int sourceLen = stringLen(source);
char *result = malloc((destLen + sourceLen) * sizeof(char));
int i = 0;
while (i < destLen) {
result[i] = dest[i];
i++;
}
int j = 0;
while (j < sourceLen) {
result[i] = source[j];
i++;
j++;
}
return result;
}
int strstr(char *dest, char *source){
int i = 0;
int j = 0;
int destLen = stringLen(dest);
int sourceLen = stringLen(source);
if(sourceLen>destLen) return -1;
while(i<destLen){
if(dest[i]==source[j]){
i++;
j++;
if(j==sourceLen){
return i-sourceLen;
}
continue;
} else {
i++;
j=0;
}
}
return -1;
}
int strchr(char *source, char target){
int i = 0;
while(source[i]!='\0'){
if(source[i]==target){
return i;
}
i++;
}
}
void* memcpy(char *dest, char* source, size_t size){
int i =0;
int destLen = stringLen(dest);
int sourceLen = stringLen(source);
while(i<size&&i<sourceLen){
dest[i] = source[i];
i++;
}
if(i<destLen){
dest[i] = '\0';
}
return dest;
}
size_t stringLen(char *source) {
int i = 0;
while (source[i++] != '\0') {
}
return i-1;
}
int main() {
char *a = "asdfwer";
char *b = strcpy(a);
printf("copy:%s\n", b);
printf("strcat:%s\n", strcat(a, "hello"));
printf("strstr:%d\n", strstr("helloword","helloworld"));
printf("strchr:%d\n", strchr("helloword",'l'));
printf("memcpy:%s\n", memcpy(malloc(sizeof(char)),"helloworld",5));
}
|
|
|
|
|
df947e31cb421d616ea0a0a99bb610e36a876113
|
|
|
|
wallet-server-ui-proxy/middleware/backup.ts
|
|
4f5bfb586a47103e606ef8d1d4eb913f51103a29
|
|
|
|
|
wallet-server-ui-proxy/middleware/backup.ts
|
|
4f5bfb586a47103e606ef8d1d4eb913f51103a29
|
|
|
|
|
wallet-server-ui-proxy/middleware/backup.ts
|
|
4f5bfb586a47103e606ef8d1d4eb913f51103a29
|
|
|
|
|
import fs from 'fs'
import path from 'path'
import { Request, Response } from 'express'
import * as WalletServer from 'wallet-ts/lib/index'
import { RunConfig } from '../type/run-config'
const Config = <RunConfig>require('../type/run-config')
const logger = require('../middleware/logger')
WalletServer.ConfigureServerURL(Config.walletServerUrl)
WalletServer.ConfigureAuthorizationHeader(Config.serverAuthHeader)
const filename = 'bitcoin-s-backup.zip'
exports.downloadBackup = (req: Request, res: Response) => {
// const r = req.body // don't currently care about request
logger.info('downloadBackup ' + Config.backupDirectory)
const fullPath = path.join(Config.backupDirectory, filename)
logger.info('fullPath: ' + fullPath + ' walletServerUrl: ' + Config.walletServerUrl)
// logger.info('auth header: ' + res.getHeader('Authorization'))
// Sanity check
try {
fs.accessSync(Config.backupDirectory) // Will throw error if directory does not exist
} catch (err) {
logger.error('downloadBackup backupDirectory is not accessible ' + Config.backupDirectory)
res.end() // Blob size 0 returned
}
// Use wallet-ts to create backup
WalletServer.ZipDataDir(fullPath).then(result => {
logger.info('ZipDataDir() complete')
if (result.result === null) { // success case
// Sanity check
try {
fs.accessSync(fullPath) // Will throw error if file does not exist
} catch (err) {
logger.error('downloadBackup fullPath is not accessible ' + fullPath)
res.end() // Blob size 0 returned
}
const readStream = fs.createReadStream(fullPath)
readStream.on('open', () =>
res.setHeader('Content-Type', 'application/zip; charset=utf-8'))
readStream.on('error',
(err) => { logger.error('readStream error ' + err) })
readStream.on('end', () => {
// Always delete backup zip after sending
fs.unlink(fullPath, function() {
// Nothing to do
})
})
readStream.pipe(res)
} else {
logger.error('downloadBackup ZipDataDir failed')
res.end() // Blob size 0 returned
}
})
}
|
|
|
|
|
c6d25c4f72141f03ee058e94885ee553877d91e6
|
|
|
|
spec/controllers/admin/choices_controller_spec.rb
|
|
d533ea22a6bbc051d6743aafb63beb3d69d8825c
|
|
|
|
|
spec/controllers/admin/choices_controller_spec.rb
|
|
d533ea22a6bbc051d6743aafb63beb3d69d8825c
|
|
|
|
|
spec/controllers/admin/choices_controller_spec.rb
|
|
d533ea22a6bbc051d6743aafb63beb3d69d8825c
|
|
|
|
|
require "rails_helper"
module Admin
RSpec.describe ChoicesController, type: :controller do
before do
logged_in_as_admin
end
describe "GET new" do
it "instantiates a new Choice" do
allow(controller).to receive(:feature_valid?)
expect(Choice).to receive(:new).and_return(double(Choice).as_null_object)
get "new"
end
it "sets @choice.feature_id to the feature_id supplied as a parameter" do
choice = Choice.new
allow(Choice).to receive(:new).and_return(choice)
get "new", params: {feature_id: 123}
expect(choice.feature_id).to eq 123
end
context "when the feature is invalid" do
it "redirects to the products page" do
allow(controller).to receive(:feature_valid?).and_return(false)
get "new"
expect(response).to redirect_to(admin_products_path)
end
end
end
end
end
|
|
|
|
|
4009b06c7f2a79a55036a8541e8d8b3d6f9a817d
|
|
|
|
|
|
29af1df36f10f28a17b56f39ad67f0c7f530b93a
|
|
|
|
|
|
|
29af1df36f10f28a17b56f39ad67f0c7f530b93a
|
|
|
|
|
|
|
29af1df36f10f28a17b56f39ad67f0c7f530b93a
|
|
|
|
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
"""Batch processing for GRD products
"""
import os
import json
import itertools
import logging
import pandas as pd
from pathlib import Path
from godale._concurrent import Executor
from ost import Sentinel1Scene
from ost.s1 import grd_to_ard
from ost.helpers import raster as ras
from ost.generic import ts_extent
from ost.generic import ts_ls_mask
from ost.generic import ard_to_ts
from ost.generic import timescan
from ost.generic import mosaic
logger = logging.getLogger(__name__)
def _create_processing_dict(inventory_df):
"""Function that creates a dictionary to handle GRD batch processing
This helper function takes the inventory dataframe and creates
a dictionary with the track as key, and all the files to process as
a list, whereas the list is
:param inventory_df:
:return:
"""
# initialize empty dictionary
dict_scenes = {}
# get relative orbits and loop through each
track_list = inventory_df["relativeorbit"].unique()
for track in track_list:
# get acquisition dates and loop through each
acquisition_dates = inventory_df["acquisitiondate"][
inventory_df["relativeorbit"] == track
].unique()
# loop through dates
for i, acquisition_date in enumerate(acquisition_dates):
# get the scene ids per acquisition_date and write into a list
single_id = inventory_df["identifier"][
(inventory_df["relativeorbit"] == track)
& (inventory_df["acquisitiondate"] == acquisition_date)
].tolist()
# add this list to the dictionary and associate the track number
# as dict key
dict_scenes[f"{track}_{i+1}"] = single_id
return dict_scenes
def create_processed_df(inventory_df, list_of_scenes, outfile, out_ls, error):
df = pd.DataFrame(columns=["identifier", "outfile", "out_ls", "error"])
for scene in list_of_scenes:
temp_df = pd.DataFrame()
# get scene_id
temp_df["identifier"] = inventory_df.identifier[
inventory_df.identifier == scene
].values
# fill outfiles/error
temp_df["outfile"] = outfile
temp_df["out_ls"] = out_ls
temp_df["error"] = error
# append to final df and delete temp_df for next loop
df = pd.concat([df, temp_df])
del temp_df
return df
def grd_to_ard_batch(inventory_df, config_file):
# load relevant config parameters
with open(config_file, "r") as file:
config_dict = json.load(file)
download_dir = Path(config_dict["download_dir"])
data_mount = Path(config_dict["data_mount"])
# where all frames are grouped into acquisitions
processing_dict = _create_processing_dict(inventory_df)
processing_df = pd.DataFrame(columns=["identifier", "outfile", "out_ls", "error"])
iter_list = []
for _, list_of_scenes in processing_dict.items():
# get the paths to the file
scene_paths = [
Sentinel1Scene(scene).get_path(download_dir, data_mount)
for scene in list_of_scenes
]
iter_list.append(scene_paths)
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=config_dict["max_workers"]
)
for task in executor.as_completed(
func=grd_to_ard.grd_to_ard,
iterable=iter_list,
fargs=(
[
str(config_file),
]
),
):
list_of_scenes, outfile, out_ls, error = task.result()
# return the info of processing as dataframe
temp_df = create_processed_df(
inventory_df, list_of_scenes, outfile, out_ls, error
)
processing_df = pd.concat([processing_df, temp_df])
return processing_df
def ards_to_timeseries(inventory_df, config_file):
with open(config_file) as file:
config_dict = json.load(file)
ard = config_dict["processing"]["single_ARD"]
ard_mt = config_dict["processing"]["time-series_ARD"]
# create all extents
_create_extents(inventory_df, config_file)
# update extents in case of ls_mask
if ard["create_ls_mask"] or ard_mt["apply_ls_mask"]:
_create_mt_ls_mask(inventory_df, config_file)
# finally create time-series
_create_timeseries(inventory_df, config_file)
def _create_extents(inventory_df, config_file):
with open(config_file, "r") as file:
config_dict = json.load(file)
processing_dir = Path(config_dict["processing_dir"])
iter_list = []
for track in inventory_df.relativeorbit.unique():
# get the burst directory
track_dir = processing_dir / track
list_of_extents = list(track_dir.glob("*/*/*bounds.json"))
# if extent does not already exist, add to iterable
if not (track_dir / f"{track}.min_bounds.json").exists():
iter_list.append(list_of_extents)
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=os.cpu_count()
)
out_dict = {"track": [], "list_of_scenes": [], "extent": []}
for task in executor.as_completed(
func=ts_extent.mt_extent,
iterable=iter_list,
fargs=(
[
str(config_file),
]
),
):
track, list_of_scenes, extent = task.result()
out_dict["track"].append(track)
out_dict["list_of_scenes"].append(list_of_scenes)
out_dict["extent"].append(extent)
return pd.DataFrame.from_dict(out_dict)
def _create_extents_old(inventory_df, config_file):
with open(config_file, "r") as file:
config_dict = json.load(file)
processing_dir = Path(config_dict["processing_dir"])
iter_list = []
for track in inventory_df.relativeorbit.unique():
# get the burst directory
track_dir = processing_dir / track
# get common burst extent
list_of_scenes = list(track_dir.glob("**/*img"))
list_of_scenes = [str(x) for x in list_of_scenes if "layover" not in str(x)]
# if extent does not already exist, add to iterable
if not (track_dir / f"{track}.extent.gpkg").exists():
iter_list.append(list_of_scenes)
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=config_dict["max_workers"]
)
out_dict = {"track": [], "list_of_scenes": [], "extent": []}
for task in executor.as_completed(
func=ts_extent.mt_extent,
iterable=iter_list,
fargs=(
[
str(config_file),
]
),
):
track, list_of_scenes, extent = task.result()
out_dict["track"].append(track)
out_dict["list_of_scenes"].append(list_of_scenes)
out_dict["extent"].append(extent)
return pd.DataFrame.from_dict(out_dict)
def _create_mt_ls_mask(inventory_df, config_file):
"""Helper function to union the Layover/Shadow masks of a Time-series
This function creates a
:param inventory_df:
:param config_file:
:return:
"""
with open(config_file, "r") as file:
config_dict = json.load(file)
processing_dir = Path(config_dict["processing_dir"])
iter_list = []
for track in inventory_df.relativeorbit.unique():
# get the burst directory
track_dir = processing_dir / track
# get common burst extent
list_of_masks = list(track_dir.glob("*/*/*_ls_mask.json"))
# if extent does not already exist, add to iterable
if not (track_dir / f"{track}.ls_mask.json").exists():
iter_list.append(list_of_masks)
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=os.cpu_count()
)
for task in executor.as_completed(func=ts_ls_mask.mt_layover, iterable=iter_list):
task.result()
def _create_mt_ls_mask_old(inventory_df, config_file):
with open(config_file, "r") as file:
config_dict = json.load(file)
processing_dir = Path(config_dict["processing_dir"])
iter_list = []
for track in inventory_df.relativeorbit.unique():
# get the burst directory
track_dir = processing_dir / track
# get common burst extent
list_of_scenes = list(track_dir.glob("**/*img"))
list_of_layover = [str(x) for x in list_of_scenes if "layover" in str(x)]
iter_list.append(list_of_layover)
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=config_dict["max_workers"]
)
out_dict = {"track": [], "list_of_layover": [], "ls_mask": [], "ls_extent": []}
for task in executor.as_completed(
func=ts_ls_mask.mt_layover,
iterable=iter_list,
fargs=(
[
str(config_file),
]
),
):
track, list_of_layover, ls_mask, ls_extent = task.result()
out_dict["track"].append(track)
out_dict["list_of_layover"].append(list_of_layover)
out_dict["ls_mask"].append(list_of_layover)
out_dict["ls_extent"].append(ls_extent)
return pd.DataFrame.from_dict(out_dict)
def _create_timeseries(inventory_df, config_file):
"""Helper function to create Timeseries out of OST ARD products
Based on the inventory GeoDataFrame and the configuration file,
this function triggers the time-series processing for all bursts/tracks
within the respective project. Each product/polarisation is treated
singularly.
Based on the ARD type/configuration settings, the function uses
SNAP's Create-Stack function to unify the grid of each scene and
applies a multi-temporal speckle filter if selected.
The output are single GeoTiff files, whereas there is the possibility to
reduce the data by converting the data format into uint8 or uint16.
This is done by linearly stretching the data between -30 and +5
for backscatter, 0 and 1 for coherence, polarimetric anisotropy #
and entropy, as well 0 and 90 for polarimetric alpha channel. All
the data is cropped to the same extent based on the minimum bounds layer.
This function executes the underlying functions using the godale framework
for parallel execution. Executor type and number of parallel processes is
defined within the configuration file.
:param inventory_df:
:type GeoDataFrame
:param config_file:
:type str/Path
:return:
"""
with open(config_file, "r") as file:
config_dict = json.load(file)
processing_dir = Path(config_dict["processing_dir"])
iter_list = []
for track in inventory_df.relativeorbit.unique():
# get the burst directory
track_dir = processing_dir / track
for pol in ["VV", "VH", "HH", "HV"]:
# see if there is actually any imagery in thi polarisation
list_of_files = sorted(
str(file) for file in list(track_dir.glob(f"20*/*data*/*ma0*{pol}*img"))
)
if len(list_of_files) <= 1:
continue
# create list of dims if polarisation is present
list_of_dims = sorted(
str(dim) for dim in list(track_dir.glob("20*/*bs*dim"))
)
iter_list.append([list_of_dims, track, "bs", pol])
executor = Executor(
executor=config_dict["executor_type"], max_workers=config_dict["max_workers"]
)
out_dict = {
"track": [],
"list_of_dims": [],
"out_files": [],
"out_vrt": [],
"product": [],
"error": [],
}
for task in executor.as_completed(
func=ard_to_ts.gd_ard_to_ts,
iterable=iter_list,
fargs=(
[
str(config_file),
]
),
):
track, list_of_dims, out_files, out_vrt, product, error = task.result()
out_dict["track"].append(track)
out_dict["list_of_dims"].append(list_of_dims)
out_dict["out_files"].append(out_files)
out_dict["out_vrt"].append(out_vrt)
out_dict["product"].append(product)
out_dict["error"].append(error)
return pd.DataFrame.from_dict(out_dict)
def timeseries_to_timescan(inventory_df, config_file):
# load ard parameters
with open(config_file, "r") as file:
config_dict = json.load(file)
processing_dir = Path(config_dict["processing_dir"])
ard = config_dict["processing"]["single_ARD"]
ard_mt = config_dict["processing"]["time-series_ARD"]
ard_tscan = config_dict["processing"]["time-scan_ARD"]
# get the db scaling right
to_db = ard["to_db"]
if ard["to_db"] or ard_mt["to_db"]:
to_db = True
dtype_conversion = True if ard_mt["dtype_output"] != "float32" else False
iter_list, vrt_iter_list = [], []
for track in inventory_df.relativeorbit.unique():
# get track directory
track_dir = processing_dir / track
# define and create Timescan directory
timescan_dir = track_dir / "Timescan"
timescan_dir.mkdir(parents=True, exist_ok=True)
# loop thorugh each polarization
for polar in ["VV", "VH", "HH", "HV"]:
if (timescan_dir / f".bs.{polar}.processed").exists():
logger.info(f"Timescans for track {track} already processed.")
continue
# get timeseries vrt
time_series = track_dir / "Timeseries" / f"Timeseries.bs.{polar}.vrt"
if not time_series.exists():
continue
# create a datelist for harmonics
scene_list = list(track_dir.glob(f"Timeseries/*bs.{polar}.tif"))
# create a datelist for harmonics calculation
datelist = []
for file in sorted(scene_list):
datelist.append(file.name.split(".")[1])
# define timescan prefix
timescan_prefix = timescan_dir / f"bs.{polar}"
iter_list.append(
[
time_series,
timescan_prefix,
ard_tscan["metrics"],
dtype_conversion,
to_db,
ard_tscan["remove_outliers"],
datelist,
]
)
vrt_iter_list.append(timescan_dir)
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=config_dict["max_workers"]
)
# run timescan creation
out_dict = {"track": [], "prefix": [], "metrics": [], "error": []}
for task in executor.as_completed(func=timescan.gd_mt_metrics, iterable=iter_list):
burst, prefix, metrics, error = task.result()
out_dict["track"].append(burst)
out_dict["prefix"].append(prefix)
out_dict["metrics"].append(metrics)
out_dict["error"].append(error)
timescan_df = pd.DataFrame.from_dict(out_dict)
# run vrt creation
for task in executor.as_completed(
func=ras.create_tscan_vrt,
iterable=vrt_iter_list,
fargs=(
[
str(config_file),
]
),
):
task.result()
return timescan_df
def mosaic_timeseries(inventory_df, config_file):
print(" -----------------------------------")
logger.info("Mosaicking Time-series layers")
print(" -----------------------------------")
# -------------------------------------
# 1 load project config
with open(config_file, "r") as ard_file:
config_dict = json.load(ard_file)
processing_dir = Path(config_dict["processing_dir"])
# create output folder
ts_dir = processing_dir / "Mosaic" / "Timeseries"
ts_dir.mkdir(parents=True, exist_ok=True)
# loop through polarisations
iter_list, vrt_iter_list = [], []
for p in ["VV", "VH", "HH", "HV"]:
tracks = inventory_df.relativeorbit.unique()
nr_of_ts = len(
list((processing_dir / f"{tracks[0]}" / "Timeseries").glob(f"*.{p}.tif"))
)
if not nr_of_ts >= 1:
continue
outfiles = []
for i in range(1, nr_of_ts + 1):
filelist = list(processing_dir.glob(f"*/Timeseries/{i:02d}.*.{p}.tif"))
filelist = [str(file) for file in filelist if "Mosaic" not in str(file)]
# create
datelist = []
for file in filelist:
datelist.append(Path(file).name.split(".")[1])
filelist = " ".join(filelist)
start, end = sorted(datelist)[0], sorted(datelist)[-1]
if start == end:
outfile = ts_dir / f"{i:02d}.{start}.bs.{p}.tif"
else:
outfile = ts_dir / f"{i:02d}.{start}-{end}.bs.{p}.tif"
check_file = outfile.parent / f".{outfile.stem}.processed"
outfiles.append(outfile)
if check_file.exists():
logger.info(f"Mosaic layer {outfile.name} already processed.")
continue
logger.info(f"Mosaicking layer {outfile.name}.")
iter_list.append([filelist, outfile, config_file])
vrt_iter_list.append([ts_dir, p, outfiles])
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=config_dict["max_workers"]
)
# run mosaicking
for task in executor.as_completed(func=mosaic.gd_mosaic, iterable=iter_list):
task.result()
# run mosaicking vrts
for task in executor.as_completed(
func=mosaic.create_timeseries_mosaic_vrt, iterable=vrt_iter_list
):
task.result()
def mosaic_timescan(config_file):
# load ard parameters
with open(config_file, "r") as ard_file:
config_dict = json.load(ard_file)
processing_dir = Path(config_dict["processing_dir"])
metrics = config_dict["processing"]["time-scan_ARD"]["metrics"]
if "harmonics" in metrics:
metrics.remove("harmonics")
metrics.extend(["amplitude", "phase", "residuals"])
if "percentiles" in metrics:
metrics.remove("percentiles")
metrics.extend(["p95", "p5"])
# create out directory of not existent
tscan_dir = processing_dir / "Mosaic" / "Timescan"
tscan_dir.mkdir(parents=True, exist_ok=True)
# loop through all pontial proucts
iter_list = []
for polar, metric in itertools.product(["VV", "HH", "VH", "HV"], metrics):
# create a list of files based on polarisation and metric
filelist = list(processing_dir.glob(f"*/Timescan/*bs.{polar}.{metric}.tif"))
# break loop if there are no files
if not len(filelist) >= 2:
continue
# get number
filelist = " ".join([str(file) for file in filelist])
outfile = tscan_dir / f"bs.{polar}.{metric}.tif"
check_file = outfile.parent / f".{outfile.stem}.processed"
if check_file.exists():
logger.info(f"Mosaic layer {outfile.name} already processed.")
continue
iter_list.append([filelist, outfile, config_file])
# now we run with godale, which works also with 1 worker
executor = Executor(
executor=config_dict["executor_type"], max_workers=config_dict["max_workers"]
)
# run mosaicking
for task in executor.as_completed(func=mosaic.gd_mosaic, iterable=iter_list):
task.result()
ras.create_tscan_vrt(tscan_dir, config_file)
|
|
|
|
|
9bc1651f5e75769617029e484b804f33c2d105f0
|
|
|
|
|
|
8d5aa79aa5ab30d405354408eb60399a345a20e1
|
|
|
|
|
|
|
31403b79476bf5176b4f18374cf87dbd67c85008
|
|
|
|
|
|
|
a0b481441d3400602b83c9f6681e6fb3f871ef05
|
|
|
|
|
const OFFLINE_VERSION = 1
const CACHE_NAME = "offline"
const OFFLINE_URL = "/offline.html"
self.addEventListener("install", ev => {
ev.waitUntil(cacheOfflinePage())
self.skipWaiting()
})
async function cacheOfflinePage() {
const cache = await caches.open(CACHE_NAME)
await cache.add(new Request(OFFLINE_URL, { cache: "reload" }))
}
self.addEventListener("activate", ev => {
ev.waitUntil(enableNavigationPreload())
self.clients.claim()
})
async function enableNavigationPreload() {
if ("navigationPreload" in self.registration) {
await self.registration.navigationPreload.enable()
}
}
self.addEventListener("fetch", ev => {
if (ev.request.mode === "navigate") {
ev.respondWith(networkWithOfflineNavigationFallback(ev))
}
})
self.addEventListener("push", ev => {
if (!ev.data) {
return
}
const n = ev.data.json()
if (!n) {
return
}
ev.waitUntil(showNotification(n))
})
self.addEventListener("notificationclick", ev => {
ev.notification.close()
ev.waitUntil(openNotificationsPage(ev.notification.data))
})
async function showNotification(n) {
const title = notificationTitle(n)
const body = notificationBody(n)
return self.registration.showNotification(title, {
body,
tag: n.id,
timestamp: n.issuedAt,
data: n,
icon: location.origin + "/icons/logo-circle-512.png",
}).then(() => {
if ("setAppBadge" in navigator) {
return navigator.setAppBadge()
}
})
}
async function openNotificationsPage(n) {
return clients.matchAll({
type: "window"
}).then(clientList => {
const pathname = notificationPathname(n)
for (const client of clientList) {
if (client.url === pathname && "focus" in client) {
return client.focus()
}
}
for (const client of clientList) {
if (client.url === "/notifications" && "focus" in client) {
return client.focus()
}
}
for (const client of clientList) {
if ("focused" in client && client.focused) {
return client.navigate(pathname).then(client => "focus" in client ? client.focus() : client)
}
if ("visibilityState" in client && client.visibilityState === "visible") {
return client.navigate(pathname).then(client => "focus" in client ? client.focus() : client)
}
}
if ("openWindow" in clients) {
return clients.openWindow(pathname)
}
}).then(client => client.postMessage({
type: "notificationclick",
detail: n,
}).then(() => {
if ("clearAppBadge" in navigator) {
return navigator.clearAppBadge()
}
}))
}
function notificationPathname(n) {
if (typeof n.postID === "string" && n.postID !== "") {
return "/posts/" + encodeURIComponent(n.postID)
}
if (n.type === "follow") {
return "/@" + encodeURIComponent(n.actors[0])
}
return "/notifications"
}
async function networkWithOfflineNavigationFallback(ev) {
try {
const preloadResponse = await ev.preloadResponse
if (preloadResponse) {
return preloadResponse
}
const networkResponse = await fetch(ev.request)
return networkResponse
} catch (error) {
const cache = await caches.open(CACHE_NAME)
const cachedResponse = await cache.match(OFFLINE_URL)
return cachedResponse
}
}
function notificationTitle(n) {
switch (n.type) {
case "follow":
return "New follow"
case "comment":
return "New commented"
case "post_mention":
return "New post mention"
case "comment_mention":
return "New comment mention"
}
return "New notification"
}
function notificationBody(n) {
const getActors = () => {
const aa = n.actors
switch (aa.length) {
case 0:
return "Someone"
case 1:
return aa[0]
case 2:
return `${aa[0]} and ${aa[1]}`
}
return `${aa[0]} and ${aa.length - 1} others`
}
const getAction = () => {
switch (n.type) {
case "follow":
return "followed you"
case "comment":
return "commented in a post"
case "post_mention":
return "mentioned you in a post"
case "comment_mention":
return "mentioned you in a comment"
}
return "did something"
}
return getActors() + " " + getAction()
}
|
|
|
|
|
5b1d05ff04a50d724df5ca369fe808fe7708e5a2
|
|
|
|
klay-demo/src/main/kotlin/klay/tests/core/CanvasStressTest.kt
|
|
72031aa267cd304a0612b31c871e2f5cf73d2c4c
|
|
|
|
|
klay-demo/src/main/kotlin/klay/tests/core/CanvasStressTest.kt
|
|
72031aa267cd304a0612b31c871e2f5cf73d2c4c
|
|
|
|
|
klay-demo/src/main/kotlin/klay/tests/core/CanvasStressTest.kt
|
|
72031aa267cd304a0612b31c871e2f5cf73d2c4c
|
|
|
|
|
package klay.tests.core
import euklid.f.MathUtil
import klay.core.Clock
import klay.scene.CanvasLayer
import kotlin.math.cos
import kotlin.math.sin
class CanvasStressTest(game: TestsGame) : Test(game, "Canvas Stress", "Animates a full-screen sized canvas, forcing a massive reupload of image data to " + "the GPU on every frame.") {
override fun init() {
val clayer = CanvasLayer(game.graphics, game.graphics.viewSize)
game.rootLayer.add(clayer)
var noSegs = 30
var direction = 1
conns.add(game.update.connect { clock: Clock ->
val canvas = clayer.begin()
canvas.clear()
canvas.setStrokeWidth(3f)
canvas.setStrokeColor(0x88ff0000.toInt())
noSegs += direction
if (noSegs > 50) direction = -1
if (noSegs < 20) direction = 1
val r = 100f
for (ii in 0..noSegs - 1) {
val angle = 2 * MathUtil.PI * ii / noSegs
val viewSize = game.plat.graphics.viewSize
val x = r * cos(angle) + viewSize.width / 2
val y = r * sin(angle) + viewSize.height / 2
canvas.strokeCircle(x, y, 100f)
}
clayer.end() // reupload the image data
})
}
}
|
|
|
|
|
709bddbffae043056480c6a72ff06e06383b5294
|
|
|
|
src/snippetgen/common/metadata/metadata_test.go
|
cclauss/discovery-artifact-manager
|
9eb6bcef290ef87006758349c725d440fbfc85d6
|
|
|
|
|
src/snippetgen/common/metadata/metadata_test.go
|
cclauss/discovery-artifact-manager
|
9eb6bcef290ef87006758349c725d440fbfc85d6
|
|
|
|
|
src/snippetgen/common/metadata/metadata_test.go
|
cclauss/discovery-artifact-manager
|
9eb6bcef290ef87006758349c725d440fbfc85d6
|
|
|
|
|
package metadata
import "testing"
func TestGetLanguage(t *testing.T) {
for _, l := range AllowedLanguages {
if g, ok := GetLanguage(l.Name); !ok {
t.Errorf("language defined but not found: %s", l.Name)
} else if g != l {
t.Errorf("found wrong language, expected %v, found %v", l, g)
}
}
}
func TestNoLanguage(t *testing.T) {
langs := [...]string{"foobar language"}
for _, l := range langs {
if _, exist := GetLanguage(l); exist {
t.Errorf("language found but should not exist: %s", l)
}
}
}
func TestRequiredLanguages(t *testing.T) {
for _, l := range RequiredLanguages {
if !l.Required {
t.Errorf("language is required but not marked required: %s", l.Name)
}
if g, ok := GetLanguage(l.Name); !ok {
t.Errorf("language required but not defined: %s", l.Name)
} else if l != g {
t.Errorf("required language different from the definition: %s", l.Name)
}
}
for _, l := range AllowedLanguages {
found := false
for _, r := range RequiredLanguages {
if l.Name == r.Name {
found = true
break
}
}
if l.Required && !found {
t.Errorf("language marked required but not in RequiredLanguages: %s", l.Name)
}
}
}
func TestGetLanguageFromExt(t *testing.T) {
for _, l := range AllowedLanguages {
if g, ok := GetLanguageFromExt(l.Ext); !ok {
t.Errorf("cannot look up extension: %s", l.Ext)
} else if l != g {
t.Errorf("language different from definition: %s", l.Name)
}
}
}
func TestNoLanguageFromExt(t *testing.T) {
langs := [...]string{"foo", "bar"}
for _, l := range langs {
if _, exist := GetLanguageFromExt(l); exist {
t.Errorf("language found but should not exist: %s", l)
}
}
}
|
|
|
|
|
a16097ae40d34fe1e6000e4d3e46862218e86dca
|
|
|
|
|
bobcatfish/adventofcode2016
|
20f781f256f4d649544c1f6e28da0d73e3bbc9e3
|
|
|
|
|
|
bobcatfish/adventofcode2016
|
20f781f256f4d649544c1f6e28da0d73e3bbc9e3
|
|
|
|
|
|
bobcatfish/adventofcode2016
|
20f781f256f4d649544c1f6e28da0d73e3bbc9e3
|
|
|
|
|
package main
import (
"fmt"
"io/ioutil"
"log"
"strings"
)
func load() ([][]string, error) {
data, err := ioutil.ReadFile("input.txt")
if err != nil {
return nil, fmt.Errorf("couldn't read file: %v", err)
}
pp := [][]string{}
for _, v := range strings.Split(string(data), "\n\n") {
pp = append(pp, strings.Fields(v))
}
return pp, nil
}
func getCounts1(a [][]string) []map[rune]struct{} {
mm := []map[rune]struct{}{}
for _, ss := range a {
m := map[rune]struct{}{}
for _, s := range ss {
for _, r := range s {
m[r] = struct{}{}
}
}
mm = append(mm, m)
}
return mm
}
func getCounts2(a [][]string) []map[rune]struct{} {
mm := []map[rune]struct{}{}
for _, ss := range a {
m := map[rune]struct{}{}
for i, s := range ss {
if i == 0 {
for _, r := range s {
m[r] = struct{}{}
}
} else {
for r, _ := range m {
found := false
for _, rr := range s {
if r == rr {
found = true
break
}
}
if !found {
delete(m, r)
}
}
}
}
mm = append(mm, m)
}
return mm
}
func sum(counts []map[rune]struct{}) int {
c := 0
for _, m := range counts {
c += len(m)
}
return c
}
func main() {
a, err := load()
if err != nil {
log.Fatalf("Couldn't load nums from file: %v", err)
}
counts1 := getCounts1(a)
fmt.Println(sum(counts1))
counts2 := getCounts2(a)
fmt.Println(sum(counts2))
}
|
|
|
|
|
70adac2679061c3253e42a94836a83bce765d64c
|
|
|
|
|
asecurityteam/vpcflow-digesterd
|
7143c659e26b26e88fd04b04e03250b783d5c9ef
|
|
|
|
|
|
asecurityteam/vpcflow-digesterd
|
7143c659e26b26e88fd04b04e03250b783d5c9ef
|
|
|
|
|
|
asecurityteam/vpcflow-digesterd
|
7143c659e26b26e88fd04b04e03250b783d5c9ef
|
|
|
|
|
package storage
import (
"bytes"
"context"
"sync"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/service/s3/s3iface"
"github.com/aws/aws-sdk-go/service/s3/s3manager"
"github.com/aws/aws-sdk-go/service/s3/s3manager/s3manageriface"
)
// ProgressMarker is an implementation of Marker which allows for marking/unmarking of digests in progress
type ProgressMarker struct {
Bucket string
Client s3iface.S3API
uploader s3manageriface.UploaderAPI
lock sync.Mutex
now func() time.Time
}
// Mark flags the digest identified by key as being "in progress"
func (m *ProgressMarker) Mark(ctx context.Context, key string) error {
m.initUploader()
now := m.now
if now == nil {
now = time.Now
}
_, err := m.uploader.UploadWithContext(ctx, &s3manager.UploadInput{
Bucket: aws.String(m.Bucket),
Key: aws.String(key + inProgressSuffix),
Body: bytes.NewReader([]byte(now().Format(time.RFC3339Nano))),
})
return err
}
// Unmark flags the digest identified by key as not being "in progress"
func (m *ProgressMarker) Unmark(ctx context.Context, key string) error {
_, err := m.Client.DeleteObjectWithContext(ctx, &s3.DeleteObjectInput{
Bucket: aws.String(m.Bucket),
Key: aws.String(key + inProgressSuffix),
})
return err
}
func (m *ProgressMarker) initUploader() {
m.lock.Lock()
defer m.lock.Unlock()
if m.uploader == nil {
m.uploader = s3manager.NewUploaderWithClient(m.Client)
}
}
|
|
|
|
|
b2ffff75cff848e9cc4d8a6143bf4d9bf43e64d3
|
|
|
|
|
|
476041288367e2098b955bc2377f442ce503e822
|
|
|
|
|
|
|
476041288367e2098b955bc2377f442ce503e822
|
|
|
|
|
|
|
476041288367e2098b955bc2377f442ce503e822
|
|
|
|
|
from multiprocessing import Pool, Manager
from time import sleep
from wmi import WMI
from win32com.client import GetObject
from subprocess import Popen
from collections import Iterable
from tqdm import tqdm
from os import getpid
from sapy_script.Session import Session
session_process = None
all_processes_id = []
def _on_init(sid, p_ids):
p_ids.append(getpid())
global session_process
app = SAP.app()
i = 0
while True:
con = app.Children(i)
if con.Children(0).Info.systemsessionid == sid:
session = con.Children(p_ids.index(getpid()))
session_process = Session(session)
break
i = i + 1
def _task_executor(task):
task['func'](task['data'])
class SAP:
def __init__(self, max_sessions=16):
self._con = None
self._tasks = []
self.max_sessions = max_sessions
self.session = lambda i=0: Session(self._con.Children(i))
@staticmethod
def app():
"""Open SAPGui"""
wmi_obj = WMI()
sap_exists = len(wmi_obj.Win32_Process(name='saplgpad.exe')) > 0
if not sap_exists:
Popen(['C:\Program Files (x86)\SAP\FrontEnd\SAPgui\saplgpad.exe'])
while True:
try:
#temp = GetObject("SAPGUI").GetScriptingEngine
#temp.Change("teste 456", "", "", "", "", ".\LocalSystem", "")
#objService.Change(,, , , , , ".\LocalSystem", "")
return GetObject("SAPGUI").GetScriptingEngine
except:
sleep(1)
pass
def connect(self, environment, client=None, user=None, password=None, lang=None, force=False):
con = SAP.app().OpenConnection(environment, True)
session = Session(con.Children(0))
if client is not None:
session.findById("wnd[0]/usr/txtRSYST-MANDT").Text = client
if user is not None:
session.findById("wnd[0]/usr/txtRSYST-BNAME").Text = user
if password is not None:
session.findById("wnd[0]/usr/pwdRSYST-BCODE").Text = password
if lang is not None:
session.findById("wnd[0]/usr/txtRSYST-LANGU").Text = lang
session.findById("wnd[0]").sendVKey(0)
# Eventual tela de mudanca de senha
change_pwd = False
try:
session.findById("wnd[1]/usr/pwdRSYST-NCODE").text = ''
session.findById("wnd[1]/usr/pwdRSYST-NCOD2").text = ''
change_pwd = True
except:
pass
if change_pwd:
raise ValueError('Please, set a new Password')
# Derruba conexão SAP
if force:
try:
session.findById("wnd[1]/usr/radMULTI_LOGON_OPT1").select()
session.findById("wnd[1]/tbar[0]/btn[0]").press()
except:
pass
else:
try:
session.findById("wnd[1]/usr/radMULTI_LOGON_OPT1").select()
session.findById("wnd[1]").sendVKey(12)
return False
except:
pass
# Teste da Conexao
if session.is_connected():
self._con = con
return True
self._con = None
return False
@property
def connected(self):
return self.session().is_connected()
@staticmethod
def session():
global session_process
return session_process
def sid(self):
return self.session().Info.systemsessionid
def logout(self):
session = self.session()
session.findById("wnd[0]/tbar[0]/okcd").text = "/nex"
session.findById("wnd[0]").sendVKey(0)
del session
self._con = None
@property
def number_of_sessions(self):
return 0 if self._con is None else len(self._con.Children)
@number_of_sessions.setter
def number_of_sessions(self, value):
size = self.number_of_sessions
if size == 0:
return
value = min(max(int(value), 1), self.max_sessions)
minus = value < size
arr = list(range(size, value))
arr.extend(reversed(range(value, size)))
for i in arr:
if minus:
session = self.session(i)
session.findById("wnd[0]/tbar[0]/okcd").text = "/i"
session.findById("wnd[0]").sendVKey(0)
else:
self.session().createSession()
sleep(0.5)
def clear_tasks(self):
self._tasks = []
def add_task(self, func, data):
for dt in data:
self._tasks.append({'func': func, 'data': dt})
def execute_tasks(self, resize_sessions=False):
total = len(self._tasks)
if total == 0:
return
if resize_sessions:
self.number_of_sessions = total
size = self.number_of_sessions
if size == 0:
return
sess_manager = Manager().list([])
pool = Pool(processes=self.number_of_sessions, initializer=_on_init, initargs=(self.sid(), sess_manager))
response = list(tqdm(pool.imap_unordered(_task_executor, self._tasks)))
pool.close()
pool.join()
return list(response)
def execute_function(self, func, data, resize_sessions=False):
if not isinstance(data, Iterable):
data = [data]
self.clear_tasks()
self.add_task(func=func, data=data)
response = self.execute_tasks(resize_sessions=resize_sessions)
self.clear_tasks()
return response
@staticmethod
def multi_arguments(func):
def convert_args(pr):
return func(**pr)
return convert_args
|
|
|
|
|
bcbdeed076feb6d35baafa8510638704f681698f
|
|
|
|
lib/stateTransition/StateTransitionFactory.js
|
|
47ae40331054a80569a4fe50ce7821f9636c2377
|
|
|
|
|
lib/stateTransition/StateTransitionFactory.js
|
|
47ae40331054a80569a4fe50ce7821f9636c2377
|
|
|
|
|
lib/stateTransition/StateTransitionFactory.js
|
|
47ae40331054a80569a4fe50ce7821f9636c2377
|
|
|
|
|
const { decode } = require('../util/serializer');
const InvalidStateTransitionError = require('./errors/InvalidStateTransitionError');
class StateTransitionFactory {
/**
* @param {validateStateTransitionStructure} validateStateTransitionStructure
* @param {createStateTransition} createStateTransition
*/
constructor(validateStateTransitionStructure, createStateTransition) {
this.validateStateTransitionStructure = validateStateTransitionStructure;
this.createStateTransition = createStateTransition;
}
/**
* Create State Transition from plain object
*
* @param {RawDataContractStateTransition|RawDocumentsStateTransition} rawStateTransition
* @param {Object} options
* @param {boolean} [options.skipValidation=false]
* @return {DataContractStateTransition|DocumentsStateTransition}
*/
async createFromObject(rawStateTransition, options = {}) {
const opts = Object.assign({ skipValidation: false }, options);
if (!opts.skipValidation) {
const result = await this.validateStateTransitionStructure(rawStateTransition);
if (!result.isValid()) {
throw new InvalidStateTransitionError(result.getErrors(), rawStateTransition);
}
}
return this.createStateTransition(rawStateTransition);
}
/**
* Create State Transition from string/buffer
*
* @param {Buffer|string} payload
* @param {Object} options
* @param {boolean} [options.skipValidation=false]
* @return {DataContractStateTransition|DocumentsStateTransition}
*/
async createFromSerialized(payload, options = { }) {
const rawStateTransition = decode(payload);
return this.createFromObject(rawStateTransition, options);
}
}
module.exports = StateTransitionFactory;
|
|
|
|
|
37fc6856bfcabca29c5192ab7cc313e4a14ce07e
|
|
|
|
VGLabel/Classes/VGLabelComponent.swift
|
|
4511f8f01189c4ad96f0b9423a15845f49e849d0
|
|
|
|
|
VGLabel/Classes/VGLabelComponent.swift
|
|
4511f8f01189c4ad96f0b9423a15845f49e849d0
|
|
|
|
|
VGLabel/Classes/VGLabelComponent.swift
|
|
4511f8f01189c4ad96f0b9423a15845f49e849d0
|
|
|
|
|
//
// VGLabelComponent.swift
// VGLabel
//
// Created by Vein on 2017/11/7.
// Copyright © 2017年 Vein. All rights reserved.
//
import Foundation
public class VGLabelComponent: NSObject {
internal var componentIndex: Int = 0
internal var text: String = ""
internal var tagLabel: String?
internal var attributes: [String: String]?
internal var position: Int = 0
class func compomemt(_ text: String, tag: String, attributes: [String: String]) -> VGLabelComponent {
return VGLabelComponent(text, tag: tag, attributes: attributes)
}
init(_ text: String, tag: String, attributes: [String: String]) {
self.text = text
self.attributes = attributes
tagLabel = tag
}
class func compomemt(_ tag: String, position: Int, attributes: [String: String]) -> VGLabelComponent {
return VGLabelComponent(tag, position: position, attributes: attributes)
}
init(_ tag: String, position: Int, attributes: [String: String]) {
self.attributes = attributes
self.position = position
tagLabel = tag
}
override public var description : String {
var desc = "text: \(text), position: \(position)"
if let tag = tagLabel {
desc += ", tag: \(tag)"
}
if let att = attributes {
desc += ", attributes: \(att)"
}
return desc
}
}
public class VGLabelExtractedComponent: NSObject {
internal var textComponents: [VGLabelComponent]?
internal var plainText: String?
class func labelExtractedComponent(_ textComponents: [VGLabelComponent], plainText: String) -> VGLabelExtractedComponent {
let extractedComponent = VGLabelExtractedComponent()
extractedComponent.textComponents = textComponents
extractedComponent.plainText = plainText
return extractedComponent
}
class func extractTextStyle(_ data: String, paragraphReplacement: String) -> VGLabelExtractedComponent {
var text: NSString? = nil
var tag: String? = nil
var styleData = data
var components = [VGLabelComponent]()
var lastPosition = 0
let scanner = Scanner(string: data)
while !scanner.isAtEnd {
scanner.scanUpTo("<", into: nil)
scanner.scanUpTo(">", into: &text)
let delimiter = String(format: "%@>", text!)
let position = (styleData as NSString).range(of: delimiter).location
if position != NSNotFound {
if delimiter.range(of: "<p")?.lowerBound.encodedOffset == 0 {
let nsRange = NSRange(location: lastPosition, length: position + delimiter.count - lastPosition)
styleData = (styleData as NSString).replacingOccurrences(of: delimiter, with: paragraphReplacement, options: .caseInsensitive, range: nsRange)
} else {
let nsRange = NSRange(location: lastPosition, length: position + delimiter.count - lastPosition)
styleData = (styleData as NSString).replacingOccurrences(of: delimiter, with: "", options: .caseInsensitive, range: nsRange)
}
styleData = styleData.replacingOccurrences(of: "<", with: "<")
styleData = styleData.replacingOccurrences(of: ">", with: ">")
}
if text?.range(of: "</").location == 0 {
// end of tag
tag = text?.substring(from: 2)
if position != NSNotFound {
for component in components.reversed() {
if component.text.count == 0, component.tagLabel == tag {
let text = (styleData as NSString).substring(with: NSRange(location: component.position, length: position - component.position))
component.text = text
break
}
}
}
} else {
// start of tag
if let textComponents = text?.substring(from: 1).components(separatedBy: " ") {
tag = textComponents[0]
var attributes = [String: String]()
for (index, textComponent) in textComponents.enumerated() {
if index == 0 { continue }
let pair = textComponent.components(separatedBy: "=")
if pair.count > 0 {
let key = pair[0].lowercased()
if pair.count >= 2 {
// Trim " charactere
var value = (pair[1...pair.count - 1]).joined(separator: "=")
value = (value as NSString).replacingOccurrences(of: "\"", with: "", options: .literal, range: NSRange(location: 0, length: 1))
value = (value as NSString).replacingOccurrences(of: "\"", with: "", options: .literal, range: NSRange(location: value.count-1, length: 1))
attributes[key] = value
} else if pair.count == 1 {
attributes[key] = key
}
}
}
let component = VGLabelComponent.compomemt("", tag: tag!, attributes: attributes)
component.position = position
components.append(component)
}
lastPosition = position
}
}
return VGLabelExtractedComponent.labelExtractedComponent(components, plainText: styleData)
}
}
|
|
|
|
|
f2cbc37b94c15a4b34d5f11c14e4a7235926cef3
|
|
|
|
|
|
cf0e59eb08a04818a8bd3d838b04b06378aa6fb6
|
|
|
|
|
|
|
cf0e59eb08a04818a8bd3d838b04b06378aa6fb6
|
|
|
|
|
|
|
cf0e59eb08a04818a8bd3d838b04b06378aa6fb6
|
|
|
|
|
function theft(n)
if ROUND.gameMode.hell and ROUND.accumulated then
ROUND.accumulated = nil
addBlockPoint(ROUND.chair[n].owner)
end
local image = {tfm.exec.addImage(IMG.misc.genericLayer, "!1000", 0, 0, ROUND.chair[n].owner)}
local option = {}
for i, v in pairs(ROUND.chair) do
if (v.mode ~= "DELETED") and i ~= n then
table.insert(image, tfm.exec.addImage(IMG.misc.target, "!1000", v.x-50, 30))
option[i] = true
end
end
ROUND.chair[n].action = {
name = "THEFT",
img = image,
op = option,
func = makeTheft
}
resetTimer()
updateTurnTimer()
end
function makeTheft(n, target)
if target then
local temp = {}
if n ~= target and ROUND.chair[target].mode ~= "DELETED" then
if ROUND.chair[n].action then
for i, v in pairs(ROUND.chair[n].action.img) do
tfm.exec.removeImage(v)
end
end
ROUND.chair[n].action = false
--
local found = {}
for i, v in pairs(ROUND.chair[target].hand) do
if v[1] == "black" then
table.insert(found, i)
end
end
if #found > 0 then
local rand = found[math.random(#found)]
temp = table.remove(ROUND.chair[target].hand, rand)
discardEffect(target, rand)
table.insert(ROUND.chair[n].hand, temp)
missCard(n, temp, 2000)
explosion(5, ROUND.chair[n].x, 100, 5, 10)
sortHand(ROUND.chair[n].hand)
ROUND.chair[n].uno = nil
updateHand(n)
updateHand(target)
if #ROUND.chair[target].hand == 1 then
ROUND.chair[target].uno = "uno"
end
if isIlluminati(n) then
unlockChair(ROUND.chair[n].owner, "illuminati")
end
if temp[2] == "draw4" then
if ROUND.chair[n].theft then
unlockChair(ROUND.chair[n].owner, "gaga")
else
ROUND.chair[n].theft = true
end
end
updateScore(n)
updateScore(target)
showCardsGainned(n, 1)
showCardsGainned(target, -1)
end
--
if #ROUND.chair[target].hand == 0 then
local name = ROUND.chair[target].owner
endGame(ROUND.chair[target].owner)
unlockChair(target, "gift")
else
passTurn()
ROUND.chair[n].confuse = false
batataTimer(n)
updateShadow(n)
end
end
else
if ROUND.chair[n].action then
for i, v in pairs(ROUND.chair[n].action.img) do
tfm.exec.removeImage(v)
end
ROUND.chair[n].action = false
end
passTurn()
batataTimer(n)
updateShadow(n)
end
end
|
|
|
|
|
3ab55339a3a98a636c9974ba92fd90088eaec34e
|
|
|
|
oracle/ora/awr/awrload.sql
|
|
a39fdffdc5a15b9a6e17dc8e6e852003a8dedf0d
|
|
|
|
|
oracle/ora/awr/awrload.sql
|
|
a39fdffdc5a15b9a6e17dc8e6e852003a8dedf0d
|
|
|
|
|
oracle/ora/awr/awrload.sql
|
|
a39fdffdc5a15b9a6e17dc8e6e852003a8dedf0d
|
|
|
|
|
/*[[Import AWR repository dump. Usage: @@NAME <directory_name> <file_name> [<new_dbid>]
--[[
@ARGS: 2
--]]
]]*/
SET SQLTIMEOUT 7200
DECLARE
dir VARCHAR2(128) := :V1;
file VARCHAR2(512) := :V2;
did INT := :V3;
root VARCHAR2(512);
dump BFILE;
len NUMBER;
stage VARCHAR2(30) := 'DBCLI_AWR';
BEGIN
SELECT MAX(directory_name), MAX(directory_path)
INTO dir, root
FROM ALL_DIRECTORIES
WHERE upper(directory_name) = upper(dir);
IF dir IS NULL THEN
raise_application_error(-20001, 'Cannot access directory: ' || :V1);
END IF;
IF NOT regexp_like(root, '[\\/]$') THEN
root := root || CASE WHEN root LIKE '%/%' THEN '/' ELSE '\' END;
END IF;
dump := bfilename(dir, file||'.dmp');
BEGIN
dbms_lob.fileopen(dump);
len := dbms_lob.getlength(dump);
dbms_lob.fileclose(dump);
EXCEPTION WHEN OTHERS THEN
raise_application_error(-20001, 'Cannot access file: ' || root || file || '.dmp');
END;
$IF DBMS_DB_VERSION.VERSION>18 $THEN
sys.dbms_workload_repository.awr_imp(dmpfile => file, dmpdir => dir, new_dbid => did);
$ELSE
BEGIN
stage := CASE sys_context('userenv', 'con_name') WHEN 'CDB$ROOT' THEN 'C##' END || stage;
EXCEPTION WHEN OTHERS NULL;
END;
$IF DBMS_DB_VERSION.VERSION>17 $THEN
sys.dbms_workload_repository.load(schname => stage, dmpfile => file, dmpdir => dir, new_dbid => did);
$ELSE
dbms_swrf_internal.awr_load(schname => stage,dmpfile => file, dmpdir => dir);
dbms_swrf_internal.move_to_awr(schname => stage, new_dbid => did);
dbms_swrf_internal.clear_awr_dbid;
$END
$END
dbms_output.put_line('AWR repository is imported from ' || root || file || '.dmp');
END;
/
|
|
|
|
|
28606435e1e5e3f888988d0dc49fb37281a76692
|
|
|
|
modules/libraries/backend/pulseaudio/init.lua
|
|
74e5977868230ddc9185f1d27a3d849440e9fb15
|
|
|
|
|
modules/libraries/backend/pulseaudio/init.lua
|
|
74e5977868230ddc9185f1d27a3d849440e9fb15
|
|
|
|
|
modules/libraries/backend/pulseaudio/init.lua
|
|
74e5977868230ddc9185f1d27a3d849440e9fb15
|
|
|
|
|
#!/usr/bin/env lua5.3
local awful = require("awful")
local wibox = require("wibox")
local gears = require("gears")
local naughty = require("naughty")
-- Define the base module
local pulseaudio = {
-- Create a new instance
new = function(self, selected_cli)
local object = {
-- There are multiple pulseaudio clis available, see below.
selected_cli = selected_cli or "pamixer"
}
setmetatable(object, self)
self.__index = self
return object
end
}
-- Signals used by this module:
-- > "pulseaudio::get_volume": used for widgets to be notified when
-- | the volume was changed by another part of the code.
-- Commands used to call the specific cli tools used to mamange pulseaudio.
-- By default, this is configured for pamixer, but on Debian, you may want to
-- override this with pulsemixer.
pulseaudio.pamixer = {}
pulseaudio.pulsemixer = {}
--------------------------------------------------
--- Get volume ---
--------------------------------------------------
-- Get the current playback volume. Callback must be nil or a function accepting
-- a number value (the volume in percent). Note that this function is not
-- intended to be called directly. Use the "pulseaudio::get_volume"-signal instead.
function pulseaudio.pamixer.get_volume(callback)
awful.spawn.easy_async({"pamixer", "--get-volume"}, function(volume)
volume = tonumber(volume)
if callback then
callback(volume)
end
awesome.emit_signal("pulseaudio::get_volume", volume)
end)
end
-- Run it automatically in a loop.
pulseaudio.pamixer.volume_updater = gears.timer {
timeout = 0.3,
call_now = true,
autostart = true,
callback = function()
pulseaudio.pamixer.get_volume()
end,
}
-- Signal that the timer is alreay running.
awesome.emit_signal("pulseaudio::volume_updater_running", true)
-- Prevent multiple instances to needlessly run at the same time.
awesome.connect_signal("pulseaudio::volume_updater_running", function(status)
if status then
notify("Stopped already running update timer!")
pulseaudio.pamixer.volume_updater:stop()
end
end)
--------------------------------------------------
--- Set volume ---
--------------------------------------------------
-- Set the current playback volume.
function pulseaudio.pamixer.set_volume(volume)
awful.spawn({"pamixer", "--set-volume", tostring(volume)})
end
-- Connect it to a signal.
awesome.connect_signal("pulseaudio::set_volume", function(volume)
pulseaudio.pamixer.set_volume(volume)
end)
--------------------------------------------------
--- Increment volume ---
--------------------------------------------------
-- Increment the volume by n or 1
function pulseaudio.pamixer.increase_volume(volume)
if not volume then volume = 1 end
awful.spawn({"pamixer", "--increase", tostring(volume)})
end
-- Connect it to a signal.
awesome.connect_signal("pulseaudio::increase_volume", function(volume)
pulseaudio.pamixer.increase_volume(volume)
end)
--------------------------------------------------
--- Decrement volume ---
--------------------------------------------------
-- Decrement the volume by n or 1
function pulseaudio.pamixer.decrease_volume(volume)
if not volume then volume = 1 end
awful.spawn({"pamixer", "--decrease", tostring(volume)})
end
-- Connect it to a signal.
awesome.connect_signal("pulseaudio::decrease_volume", function(volume)
pulseaudio.pamixer.decrease_volume(volume)
end)
--------------------------------------------------
--- Mute status ---
--------------------------------------------------
-- Get the current mute status. true = muted, false = unmuted.
-- Callback must be nil or a function accepting a boolean value.
-- Note that this function is not intended to be called directly.
-- Use the "pulseaudio::get_mute"-signal instead.
function pulseaudio.pamixer.get_mute(callback)
awful.spawn.easy_async({"pamixer", "--get-mute"}, function(status)
-- cli commands always return a string and lua does not have a
-- `tobool()`-builtin.
if status == "true" then
status = true
else
status = false
end
if callback then
callback(tonumber(status))
end
awesome.emit_signal("pulseaudio::get_mute", status)
end)
end
--------------------------------------------------
--- Mute ---
--------------------------------------------------
-- Mute the volume
function pulseaudio.pamixer.mute()
awful.spawn({"pamixer", "--mute"})
end
-- Connect it to a signal.
awesome.connect_signal("pulseaudio::mute", function()
pulseaudio.pamixer.mute()
end)
--------------------------------------------------
--- Unmute ---
--------------------------------------------------
-- Unmute the volume
function pulseaudio.pamixer.unmute()
awful.spawn({"pamixer", "--mute"})
end
-- Connect it to a signal.
awesome.connect_signal("pulseaudio::unmute", function()
pulseaudio.pamixer.mute()
end)
--------------------------------------------------
--- Toggle mute ---
--------------------------------------------------
-- Unmute the volume
function pulseaudio.pamixer.unmute()
awful.spawn({"pamixer", "--toggle-mute"})
end
-- Connect it to a signal.
awesome.connect_signal("pulseaudio::toggle_mute", function()
pulseaudio.pamixer.mute()
end)
--------------------------------------------------
--- Widgets ---
--------------------------------------------------
-- A few basic widgets for managing volume. Can be used as templates for
-- creating your own, more advanced (or nicer looking) ones.
pulseaudio.widget = {}
--------------------------------------------------
--- Slider ---
--------------------------------------------------
-- A basic volume slider based on wibox.widget.slider
-- The first argument must be arguments for wibox.widget.slider
-- as a table or nil.
function pulseaudio.widget.volume_slider(args) --> table
-- Set a few basic default options if none are given.
if not args then
args = {
minimum = 0,
value = 50,
maximum = 100,
forced_width = 200,
}
end
-- Create a new slider widget.
local slider = wibox.widget.slider(args)
-- Connect the widget to the volume signal.
awesome.connect_signal("pulseaudio::get_volume", function(volume)
slider:set_value(volume)
end)
-- Allow to set the volume using the mouse wheel.
slider:connect_signal("button::press", function(_,_,_,button)
if button == 4 then
awesome.emit_signal("pulseaudio::increase_volume", 5)
elseif button == 5 then
awesome.emit_signal("pulseaudio::decrease_volume", 5)
end
end)
-- Change the system volume when the slider value changes.
slider:connect_signal("property::value", function()
awesome.emit_signal("pulseaudio::set_volume", slider.value)
end)
return slider
end
--------------------------------------------------
--- Text label ---
--------------------------------------------------
function pulseaudio.widget.volume_label(args) --> table
-- Create a new slider widget.
local label = wibox.widget.textbox(args)
-- Connect the widget to the volume signal.
awesome.connect_signal("pulseaudio::get_volume", function(volume)
label:set_text(volume)
end)
-- Allow to (un-)mute by left clicking the label and to
-- set the volume using the mouse wheel.
label:connect_signal("button::press", function(_,_,_,button)
if button == 1 then
awesome.emit_signal("pulseaudio::toggle_mute")
elseif button == 4 then
awesome.emit_signal("pulseaudio::increase_volume", 5)
elseif button == 5 then
awesome.emit_signal("pulseaudio::decrease_volume", 5)
end
end)
return label
end
--------------------------------------------------
--- Status notifications ---
--------------------------------------------------
pulseaudio.notification = {
volume = { enabled = false },
mute = { enabled = false },
}
function pulseaudio.notification.volume:enable()
self.enabled = true
awesome.connect_signal("pulseaudio::get_volume", function(volume)
naughty.notification {
title = "Volume change",
message = "Current volume: " .. tostring(volume),
category = "pulseaudio.volume",
app_name = "pulseaudio_cli_awesome_bindings",
timeout = 1,
}
end)
end
function pulseaudio.notification.volume:disable()
self.enabled = false
awesome.disconnect_signal("pulseaudio::get_volume")
end
function pulseaudio.notification.volume:toggle()
if self.enabled then
self:disable()
else
self:enable()
end
end
function pulseaudio.notification.mute:enable()
self.enabled = true
awesome.connect_signal("pulseaudio::get_mute", function(muted)
local title = "Unmuted"
local text = "System unmuted"
if muted then
title = "Muted"
text = "System muted"
end
naughty.notification {
title = title,
message = text,
category = "pulseaudio.mute",
app_name = "pulseaudio_cli_awesome_bindings",
timeout = 1,
}
end)
end
function pulseaudio.notification.mute:disable()
self.enabled = false
awesome.disconnect_signal("pulseaudio::get_mute")
end
function pulseaudio.notification.mute:toggle()
if self.enabled then
self:disable()
else
self:enable()
end
end
-- Select the correct cli tool.
if pulseaudio.current_cli == "pamixer" then
pulseaudio.cli = pulseaudio.pamixer
elseif pulseaudio.current_cli == "pulsemixer" then
pulseaudio.cli = pulseaudio.pulsemixer
end
return pulseaudio:new()
|
|
|
|
|
99412084ad8354eeac28b286ec51d9199233a7ad
|
|
|
|
|
|
c8701b170e4e2cbdb4d52fe3b7c8529afb3e97ed
|
|
|
|
|
|
|
c8701b170e4e2cbdb4d52fe3b7c8529afb3e97ed
|
|
|
|
|
|
|
c8701b170e4e2cbdb4d52fe3b7c8529afb3e97ed
|
|
|
|
|
#pragma once
//-----------------------------------------------------------------------------
class Crc
{
public:
Crc() : m_crc(CRC32_NEGL) {}
void Update(const byte *input, size_t length);
uint Get() const { return ~m_crc; }
operator uint() const { return Get(); }
// Don't use for types with padding!
template<typename T>
void Update(const T& item)
{
Update((const byte*)&item, sizeof(item));
}
template<>
void Update(const string& str)
{
if(!str.empty())
Update((const byte*)str.c_str(), str.length());
}
template<>
void Update(const cstring& str)
{
assert(str);
Update((const byte*)str, strlen(str));
}
// Don't use for types with padding!
template<typename T>
void Update(const vector<T>& v)
{
Update(v.size());
if(!v.empty())
Update((const byte*)v.data(), v.size() * sizeof(T));
}
template<>
void Update(const vector<string>& v)
{
Update(v.size());
for(const string& s : v)
Update(s);
}
void Update0()
{
Update<byte>(0);
}
void Update1()
{
Update<byte>(1);
}
static uint Calculate(Cstring filename);
static uint Calculate(FileReader& file);
private:
static const uint CRC32_NEGL = 0xffffffffL;
static const uint m_tab[256];
uint m_crc;
};
|
|
|
|
|
c7d423fa068508464eb1bdffe43ab9ac7402f665
|
|
|
|
|
|
edef4cfeb31c4ea52cc67dce581372e2270fce2a
|
|
|
|
|
|
|
edef4cfeb31c4ea52cc67dce581372e2270fce2a
|
|
|
|
|
|
|
edef4cfeb31c4ea52cc67dce581372e2270fce2a
|
|
|
|
|
# Author: Vlad Niculae <[email protected]>
# License: BSD 3 clause
from __future__ import print_function
from __future__ import division
import numpy as np
from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
from sklearn.utils.extmath import safe_sparse_dot
from sklearn.isotonic import isotonic_regression
from sklearn.preprocessing import LabelBinarizer
from fista import fista
from loss import get_loss
def prox_owl(v, w):
"""Proximal operator of the OWL norm dot(w, reversed(sort(v)))
Follows description and notation from:
X. Zeng, M. Figueiredo,
The ordered weighted L1 norm: Atomic formulation, dual norm,
and projections.
eprint http://arxiv.org/abs/1409.4271
"""
# wlog operate on absolute values
v_abs = np.abs(v)
ix = np.argsort(v_abs)[::-1]
v_abs = v_abs[ix]
# project to K+ (monotone non-negative decreasing cone)
v_abs = isotonic_regression(v_abs - w, y_min=0, increasing=False)
# undo the sorting
inv_ix = np.zeros_like(ix)
inv_ix[ix] = np.arange(len(v))
v_abs = v_abs[inv_ix]
return np.sign(v) * v_abs
def _oscar_weights(alpha, beta, size):
w = np.arange(size - 1, -1, -1, dtype=np.double)
w *= beta
w += alpha
return w
def _fit_owl_fista(X, y, w, loss, max_iter=500, max_linesearch=20, eta=2.0,
tol=1e-3, verbose=0):
# least squares loss
def sfunc(coef, grad=False):
y_scores = safe_sparse_dot(X, coef)
if grad:
obj, lp = loss(y, y_scores, return_derivative=True)
grad = safe_sparse_dot(X.T, lp)
return obj, grad
else:
return loss(y, y_scores)
def nsfunc(coef, L):
return prox_owl(coef, w / L)
coef = np.zeros(X.shape[1])
return fista(sfunc, nsfunc, coef, max_iter, max_linesearch,
eta, tol, verbose)
class _BaseOwl(BaseEstimator):
"""
Solves sum loss(y_pred, y) + sum_j weights_j |coef|_(j)
where u_(j) is the jth largest component of the vector u.
and weights is a monotonic nonincreasing vector.
OWL is also known as: sorted L1 norm, SLOPE
Parameters
----------
weights: array, shape (n_features,) or tuple, length 2
Nonincreasing weights vector for the ordered weighted L1 penalty.
If weights = (alpha, 0, 0, ..., 0), this amounts to a L_inf penalty.
If weights = alpha * np.ones(n_features) it amounts to L1.
If weights is a tuple = (alpha, beta), the OSCAR penalty is used::
alpha ||coef||_1 + beta sum_{i<j} max{|x_i|, |x_j|)
by computing the corresponding `weights` vector as::
weights_i = alpha + beta(n_features - i - 1)
loss: string, default: "squared"
Loss function to use, see loss.py to add your own.
max_iter: int, default: 500
Maximum FISTA iterations.
max_linesearch: int, default: 20
Maximum number of FISTA backtracking line search steps.
eta: float, default: 2
Amount by which to increase step size in FISTA bactracking line search.
tol: float, default: 1e-3
Tolerance for the convergence criterion.
verbose: int, default 0:
Degree of verbosity to print from the solver.
References
----------
X. Zeng, M. Figueiredo,
The ordered weighted L1 norm: Atomic formulation, dual norm,
and projections.
eprint http://arxiv.org/abs/1409.4271
"""
def __init__(self, weights, loss='squared', max_iter=500,
max_linesearch=20, eta=2.0, tol=1e-3, verbose=0):
self.weights = weights
self.loss = loss
self.max_iter = max_iter
self.max_linesearch = max_linesearch
self.eta = eta
self.tol = tol
self.verbose = verbose
def fit(self, X, y):
n_features = X.shape[1]
loss = self.get_loss()
weights = self.weights
if isinstance(weights, tuple) and len(weights) == 2:
alpha, beta = self.weights
weights = _oscar_weights(alpha, beta, n_features)
self.coef_ = _fit_owl_fista(X, y, weights, loss, self.max_iter,
self.max_linesearch, self.eta, self.tol,
self.verbose)
return self
def _decision_function(self, X):
return safe_sparse_dot(X, self.coef_)
class OwlRegressor(_BaseOwl, RegressorMixin):
"""Ordered Weighted L1--penalized (OWL) regression solved by FISTA"""
__doc__ += _BaseOwl.__doc__
def get_loss(self):
if self.loss != 'squared':
raise NotImplementedError('Only regression loss implemented '
'at the moment is squared.')
return get_loss(self.loss)
def predict(self, X):
return self._decision_function(X)
class OwlClassifier(_BaseOwl, ClassifierMixin):
"""Ordered Weighted L1--penalized (OWL) classification solved by FISTA"""
__doc__ += _BaseOwl.__doc__
def get_loss(self):
return get_loss(self.loss)
def fit(self, X, y):
self.lb_ = LabelBinarizer(neg_label=-1)
y_ = self.lb_.fit_transform(y).ravel()
return super(OwlClassifier, self).fit(X, y_)
def decision_function(self, X):
return self._decision_function(X)
def predict(self, X):
y_pred = self.decision_function(X) > 0
return self.lb_.inverse_transform(y_pred)
if __name__ == '__main__':
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_boston, load_breast_cancer
print("OSCAR proximal operator on toy example:")
v = np.array([1, 3, 2.9, 4, 0])
w_oscar = _oscar_weights(alpha=0.01, beta=1, size=5)
print(prox_owl(v, w_oscar))
print()
print("Regression")
X, y = load_boston(return_X_y=True)
X = np.column_stack([X, -X[:, 0] + 0.01 * np.random.randn(X.shape[0])])
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
clf = OwlRegressor(weights=(1, 100))
clf.fit(X_tr, y_tr)
print("Correlated coefs", clf.coef_[0], clf.coef_[-1])
print("Test score", clf.score(X_te, y_te))
print()
print("Classification")
X, y = load_breast_cancer(return_X_y=True)
X = np.column_stack([X, -X[:, 0] + 0.01 * np.random.randn(X.shape[0])])
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
clf = OwlClassifier(weights=(1, 100), loss='squared-hinge')
clf.fit(X_tr, y_tr)
print("Correlated coefs", clf.coef_[0], clf.coef_[-1])
print("Test score", clf.score(X_te, y_te))
|
|
|
|
|
816541fd0ac9aa27940ad0ee8d31a1aaaa0de62e
|
|
|
|
typebinder/src/pipeline/mod.rs
|
|
850f28f2286714e47ddc9179c56718b634cef279
|
|
|
|
|
typebinder/src/pipeline/mod.rs
|
|
a5414b57ce8d6dcd8b57c9ea08c7a1ab646c5380
|
|
|
|
|
typebinder/src/pipeline/mod.rs
|
|
850f28f2286714e47ddc9179c56718b634cef279
|
|
|
|
|
//! The core logic of `typebinder`
use crate::{
contexts::type_solving::TypeSolvingContext, error::TsExportError, exporters::Exporter,
macros::context::MacroSolvingContext, path_mapper::PathMapper,
step_spawner::PipelineStepSpawner,
};
use syn::{punctuated::Punctuated, Path};
use self::module_step::{ModuleStepResult, ModuleStepResultData};
pub mod module_step;
pub mod step_result;
/// The Pipeline is the starting point of `typebinder`.
///
/// A Pipeline is customized with both a [PipelineStepSpawner] and an [Exporter] implementor.
///
/// When launched, the [Pipeline] will use its [PipelineStepSpawner] to spawn the "default" module, that is, the module with an empty path.
/// Each [ModuleStep](crate::pipeline::module_step::ModuleStep) thereby generated is then launched, see [ModuleStep::launch](crate::pipeline::module_step::ModuleStep).
///
/// Each output is passed to the [Exporter], that is responsible for outputting the data.
pub struct Pipeline<PSS, E> {
pub pipeline_step_spawner: PSS,
pub exporter: E,
pub path_mapper: PathMapper,
}
impl<PSS, E> Pipeline<PSS, E>
where
PSS: PipelineStepSpawner,
E: Exporter,
TsExportError: From<PSS::Error> + From<E::Error>,
{
pub fn launch(
mut self,
solving_context: &TypeSolvingContext,
macro_context: &MacroSolvingContext,
) -> Result<(), TsExportError> {
let path = Path {
leading_colon: None,
segments: Punctuated::default(),
};
let res = self
.pipeline_step_spawner
.create_process(path)?
.ok_or(TsExportError::FailedToLaunch)?
.launch(
&self.pipeline_step_spawner,
solving_context,
macro_context,
&self.path_mapper,
)?;
let mut all_results: Vec<ModuleStepResultData> = Vec::new();
extractor(&mut all_results, res);
for result_data in all_results.into_iter() {
if result_data.imports.is_empty() && result_data.exports.is_empty() {
continue;
}
self.exporter.export_module(result_data)?;
}
self.exporter.finish();
Ok(())
}
}
/// TODO: refactor this to a closure
fn extractor(all: &mut Vec<ModuleStepResultData>, iter: ModuleStepResult) {
iter.children
.into_iter()
.for_each(|child| extractor(all, child));
all.push(iter.data);
}
|
|
|
|
|
b6d937c6bf167ae0e8646a47e76aaee72e16392d
|
|
|
|
swift-sdk/CommerceItem.swift
|
|
8c22e0390b47ff3fecf0ae6b2b71fefa180eb904
|
|
|
|
|
swift-sdk/CommerceItem.swift
|
|
8c22e0390b47ff3fecf0ae6b2b71fefa180eb904
|
|
|
|
|
swift-sdk/CommerceItem.swift
|
|
8c22e0390b47ff3fecf0ae6b2b71fefa180eb904
|
|
|
|
|
//
// Created by Tapash Majumder on 6/6/18.
// Copyright © 2018 Iterable. All rights reserved.
//
import UIKit
/**
`CommerceItem` represents a product. These are used by the commerce API; see [IterableAPI trackPurchase:items:dataFields:]
*/
@objcMembers public class CommerceItem: NSObject {
/** id of this product */
public var id: String
/** name of this product */
public var name: String
/** price of this product */
public var price: NSNumber
/** quantity of this product */
public var quantity: UInt
/**
Creates a `CommerceItem` with the specified properties
- parameters:
- id: id of the product
- name: name of the product
- price: price of the product
- quantity: quantity of the product
- returns: an instance of `CommerceItem` with the specified properties
*/
public init(id: String, name: String, price: NSNumber, quantity: UInt) {
self.id = id
self.name = name
self.price = price
self.quantity = quantity
}
/**
A Dictionary respresentation of this item
- returns: An NSDictionary representing this item
*/
public func toDictionary() -> [AnyHashable: Any] {
return ["id": id,
"name": name,
"price": price,
"quantity": quantity]
}
}
|
|
|
|
|
403ed8c759891b08ee51690d9702e340ed6f4833
|
|
|
|
instascrape/exceptions.py
|
|
7aaf3c1a1786bbe80059ed6e0d93442a19a6f475
|
|
|
|
|
instascrape/exceptions.py
|
|
7aaf3c1a1786bbe80059ed6e0d93442a19a6f475
|
|
|
|
|
instascrape/exceptions.py
|
|
7aaf3c1a1786bbe80059ed6e0d93442a19a6f475
|
|
|
|
|
class InstascrapeError(Exception):
"""Base exception class for all of the exceptions raised by Instascrape."""
class ExtractionError(InstascrapeError):
"""Raised when Instascrape fails to extract specified data from HTTP response."""
def __init__(self, message: str):
super().__init__("Failed to extract data from response. (message: '{0}')".format(message))
class PrivateAccessError(InstascrapeError):
"""Raised when user does not have permission to access specified data, i.e. private profile which the user is not following."""
def __init__(self):
super().__init__("The user profile is private and not being followed by you.")
class RateLimitedError(InstascrapeError):
"""Raised when Instascrape receives a 429 TooManyRequests from Instagram."""
def __init__(self):
super().__init__("(429) Too many requests. Failed to query data. Rate limited by Instagram.")
class NotFoundError(InstascrapeError):
"""Raised when Instascrape receives a 404 Not Found from Instagram."""
def __init__(self, message: str = None):
super().__init__(message or "(404) Nothing found.")
class ConnectionError(InstascrapeError):
"""Raised when Instascrape fails to connect to Instagram server."""
def __init__(self, url: str):
super().__init__("Failed to connect to '{0}'.".format(url))
class LoginError(InstascrapeError):
"""Raised when Instascrape fails to perform authentication, e.g. wrong credentials."""
def __init__(self, message: str):
super().__init__("Failed to log into Instagram. (message: '{0}')".format(message))
class TwoFactorAuthRequired(LoginError):
"""Raised when Instascrape fails to perform authentication due to two-factor authenticattion."""
def __init__(self):
super().__init__("two-factor authentication is required")
class CheckpointChallengeRequired(LoginError):
"""Raised when Instascrape fails to perform authentication due to checkpoint challenge."""
def __init__(self):
super().__init__("checkpoint challenge solving is required")
class AuthenticationRequired(InstascrapeError):
"""Raised when anonymous/unauthenticated (guest) user tries to perform actions that require authentication."""
def __init__(self):
super().__init__("Login is required in order to perform this action.")
class DownloadError(InstascrapeError):
"""Raised when Instascrape fails to download data from Instagram server."""
def __init__(self, message: str, url: str):
super().__init__("Download Failed -> {0} (url: '{1}')".format(message, url))
|
|
|
|
|
c7c0ddf187a121fa94e350a87f3a1a34fe08c11c
|
|
|
|
|
|
38dcb03764e00b84010eaa61dbec79c087dc9295
|
|
|
|
|
|
|
38dcb03764e00b84010eaa61dbec79c087dc9295
|
|
|
|
|
|
|
38dcb03764e00b84010eaa61dbec79c087dc9295
|
|
|
|
|
from headers import *
import globalVar
from globalVar import TOP, BOTTOM, LIVES, HT, WIDTH, LEFT, RIGHT, obj_bricks, paddle, ALT_LIVES
rows = HT
cols = WIDTH
class Ball:
"""docstring for Ball
contains all methods that can modify state of the ball.
"""
def __init__(self, x, y, vx, vy, m):
super().__init__()
self.width = 1
self.height = 1
self.x = x
self.y = y
self.v_x = vx
self.v_y = -1
self.moving = m
self.thru = 0
self.dead = 0
self.fast = 0
self.fire = 0
def move(self,v=1):
paddle=globalVar.paddle
temp = self.v_x
if(self.moving == 0): # movement with paddle
if(paddle.x+paddle.width>=RIGHT and v>0):
v = 0
elif(paddle.x<=LEFT and v<0):
v = 0
self.x += v*paddle.v
return
self.x += self.v_x
if(self.x+self.width>=RIGHT and self.v_x>0):
self.v_x = -self.v_x
elif(self.x<=LEFT and self.v_x<0):
self.v_x = -self.v_x
elif(self.x+self.v_x+self.width>RIGHT):
self.x = RIGHT-self.v_x-self.width
elif(self.x+self.v_x<LEFT):
self.x = LEFT-self.v_x
if(self.v_x!=temp):
os.system('aplay -q ./sounds/ball_wall.wav&')
self.y += self.v_y
temp = self.v_y
if(self.y+self.height>=BOTTOM and self.v_y>0): # v_y>0 means it will go down
self.kill_ball()
return
elif(self.y<=TOP and self.v_y<0):
self.v_y = -self.v_y
if(self.y+self.v_y>BOTTOM):
self.y = BOTTOM-self.height
# self.kill_ball()
return
elif(self.y+self.v_y<TOP):
# self.v_y = -self.v_y
self.y = TOP-self.v_y
if(self.v_y!=temp):
os.system('aplay -q ./sounds/ball_wall.wav&')
def check_paddle_collision(self):
paddle = globalVar.paddle
check =0
if(self.x+self.width > paddle.x and self.x<paddle.x+paddle.width): # ball is within x coordinates of paddle
if(self.y+self.height==paddle.y):
self.set_vel(- self.v_y)
if(paddle.is_sticky()):
self.moving = 0
os.system('aplay -q ./sounds/ball_paddle.wav&')
return 1
if(self.x+self.width<paddle.x+paddle.width and self.x+self.v_x+self.width>paddle.x and self.v_x>=0): # top-left collision possible
if(self.y+self.height<paddle.y and self.y+self.v_y+self.height>paddle.y):
# top-left collision
self.y = paddle.y-self.height - self.v_y
check=1
elif(self.x>(paddle.x) and self.x+self.v_x<paddle.width+paddle.x and self.v_x<=0): # top-right collision possible
if(self.y+self.height<paddle.y and self.v_y+self.y+self.height>paddle.y):
# top-right collision
# self.set_vel(-self.v_y)
self.y = paddle.y-self.height - self.v_y
check=1
return check
def check_brick_collision(self):
check = 0
v_x=self.v_x
v_y=self.v_y
for brick in reversed(globalVar.obj_bricks):
if(brick.is_broken()):
continue
if((self.x>=brick.getx() and self.x+self.width<=brick.getx()+brick.width) and ((self.y<=brick.gety()+brick.height and self.y+self.height>=brick.gety() and self.v_y<0) or (self.y+self.height>=brick.gety() and self.y<=brick.gety()+brick.height and self.v_y>0)) ):
if(self.v_y==0): #not possible, but okay
continue
# collision with top or bottom brick surface
v_y = -self.v_y
check = 1
elif(((self.x+self.width==brick.getx() and self.v_x>0) or (self.x==brick.getx()+brick.width and self.v_x<0)) and (self.y+self.height<=brick.gety()+brick.height and self.y>=brick.gety())):
if(self.v_x==0):
continue
# collision with left or right edge of brick
v_x = -self.v_x
check = 1
if(check):
if(self.thru==0):
self.v_y = v_y
self.v_x = v_x
else:
if(brick.strength == 100): # exploding
brick.reduce_strength(self.v_x, self.v_y)
break
if(self.fire==0):
brick.break_it(self.v_x, self.v_y)
else:
brick.fire(self.v_x, self.v_y)
break
if(brick.strength != -1):
if(self.fire):
brick.fire(self.v_x, self.v_y)
else:
brick.reduce_strength(self.v_x, self.v_y)
else:
if(self.fire):
brick.fire(self.v_x, self.v_y)
break
if(check):
os.system('aplay -q ./sounds/ball_brick.wav&')
return
check=0
for brick in globalVar.obj_bricks:
if(brick.is_broken()):
continue
if((self.x+self.width)==brick.getx() and self.v_x>0): # top-left or bottom-left collision possible
if(self.y==brick.gety()+brick.height and self.v_y<0):
# bottom-left collision
v_y = -self.v_y
v_x = -self.v_x
# self.v_x = -self.v_x
check = 1
elif(self.y+self.height==brick.gety() and self.v_y>0):
# top-left collision
# self.v_y = -self.v_y
v_x = -self.v_x
v_y = -self.v_y
check = 1
elif(self.x==(brick.getx()+brick.width) and self.v_x<0): # top-right or bottom-right collision possible
if(self.y==brick.gety()+brick.height and self.v_y<0):
# bottom-right collision
v_y = -self.v_y
v_x = -self.v_x
# self.v_x = -self.v_x
check = 1
elif(self.y+self.height==brick.gety() and self.v_y>0):
# top-right collision
# self.v_y = -self.v_y
v_x = -self.v_x
v_y = -self.v_y
check = 1
if(check):
# ball-brick collision occurred, reduce brick strength now
os.system('aplay -q ./sounds/ball_brick.wav&')
if(self.thru==0):
self.v_y = v_y
self.v_x = v_x
else:
# if thru ball power up is activated, destroy bricks
if(brick.strength == 100): # exploding brick
brick.reduce_strength(self.v_x, self.v_y)
break
if(self.fire==0):
brick.break_it(self.v_x, self.v_y)
else:
# if fire ball power up is activated, destroy bricks exploding bricks style
brick.fire(self.v_x, self.v_y)
break
if(brick.strength != -1):
if(self.fire):
brick.fire(self.v_x, self.v_y)
else:
brick.reduce_strength(self.v_x, self.v_y)
else:
# unbreakable brick breaks only if the ball is fireball
if(self.fire):
brick.fire(self.v_x, self.v_y)
break
if(check):
return
check=0
for brick in globalVar.obj_bricks:
if(brick.is_broken()):
continue
if(self.x+self.width<brick.getx() or self.x>brick.getx()+brick.width or self.y+self.height<brick.gety() or self.y>brick.gety()+brick.height):
x = self.x+self.v_x
y = self.y + self.v_y
for b_x in range(brick.getx(),brick.getx()+brick.width):
for b_y in range(brick.gety(),brick.gety()+brick.height):
if(x==b_x and y==b_y):
if(self.v_x>0 and self.v_y>0): # approaching from north west
if(x-brick.getx()<y-brick.gety()):
v_x = -self.v_x
elif(x-brick.getx()==y-brick.gety()):
v_x = -self.v_x
v_y = -self.v_y
else:
v_y = -self.v_y
elif(self.v_x<0 and self.v_y>0): # approaching from north east
if(brick.getx()+brick.width-x<y-brick.gety()):
v_x = -self.v_x
elif(brick.getx()+brick.width-x==y-brick.gety()):
v_x = -self.v_x
v_y = -self.v_y
else:
v_y = -self.v_y
elif(self.v_x>0 and self.v_y<0): # approaching from south west
if(x-brick.getx()<brick.gety()+brick.height-y):
v_x = -self.v_x
elif(x-brick.getx()==brick.gety()+brick.height-y):
v_x = -self.v_x
v_y = -self.v_y
else:
v_y = -self.v_y
elif(self.v_x<0 and self.v_y<0): # approaching from south east
if(brick.getx()+brick.width-x<brick.gety()+brick.height-y):
v_x = -self.v_x
elif(brick.getx()+brick.width-x==brick.gety()+brick.height-y):
v_x = -self.v_x
v_y = -self.v_y
else:
v_y = -self.v_y
check = 1
break
if(check==1):
break
if(check):
os.system('aplay -q ./sounds/ball_brick.wav&')
if(self.thru==0):
self.x += self.v_x
self.y += self.v_y
self.v_y = v_y
self.v_x = v_x
else:
if(brick.strength == 100):
brick.reduce_strength(self.v_x, self.v_y)
break
if(self.fire==0):
brick.break_it(self.v_x, self.v_y)
else:
brick.fire(self.v_x, self.v_y)
break
if(brick.strength != -1):
if(self.fire):
brick.fire(self.v_x, self.v_y)
else:
brick.reduce_strength(self.v_x, self.v_y)
else:
if(self.fire):
brick.fire(self.v_x, self.v_y)
break
def kill_ball(self):
p = globalVar.paddle
if(p==None):
return
os.system('aplay -q ./sounds/lose_life.wav&')
if(globalVar.ALT_LIVES>0):
globalVar.ALT_LIVES -= 1
self.dead = 1
else:
l = globalVar.LIVES
globalVar.LIVES = l-1
for power_up in globalVar.power_ups:
if(power_up.is_activated()):
power_up.deactivate_power_up()
self.x = random.randint(p.x, p.x+p.width-self.width)
self.y = p.y-self.height
self.moving = 0
self.v_y = -2
self.v_x = 0
self.thru = 0
self.fast = 0
self.fire = 0
def set_props(self, x, y, vx, vy):
self.x = x
self.y = y
self.v_x = vx
self.v_y = vy
def is_moving(self):
return self.moving
def set_moving(self):
self.moving = 1
if(not globalVar.paddle.is_sticky()):
self.set_vel()
def set_vel(self, vy=-1):
paddle = globalVar.paddle
cen = paddle.width//2
p1 = cen//2
p3 = cen+p1
if(self.x - paddle.x<=p1):
self.v_x = self.v_x - 2
elif(self.x - paddle.x<cen):
self.v_x = self.v_x - 1
elif(self.x - paddle.x==cen):
self.v_x = self.v_x
elif(self.x - paddle.x<=p3):
self.v_x += 1
elif(self.x - paddle.x>p3):
self.v_x += 2
self.v_y = vy
def incr_vel(self):
if(self.fast):
return
self.fast = 1
if(self.v_y > 0):
self.v_y += 1
elif(self.v_y < 0 or not (self.is_moving())):
self.v_y -= 1
def decr_vel(self):
if(self.fast):
self.fast =0
if(self.v_y > 0):
self.v_y -= 1
elif(self.v_y < 0):
self.v_y += 1
def getArr(self, colour, symbol, arr):
y = self.y
h = self.height
w = self.width
x = self.x
for i in range(y, y+h):
for j in range(x,x+w):
arr[i][j] = (colour +symbol + Style.RESET_ALL)
return arr
def set_thru(self):
self.thru = 1
def unset_thru(self):
self.thru = 0
def set_fire(self):
self.fire = 1
def unset_fire(self):
self.fire = 0
|
|
|
|
|
1bde984571b7f4f4e48121c1095f28ca435b7f01
|
|
|
|
|
|
a52e69c712c10934bc88c0b75b3f536e12303c83
|
|
|
|
|
|
|
a52e69c712c10934bc88c0b75b3f536e12303c83
|
|
|
|
|
|
|
a52e69c712c10934bc88c0b75b3f536e12303c83
|
|
|
|
|
# -*- coding:utf-8 -*-
import os
import six
from .pystring import PyString
class PyFile(object):
"""More human-friendly file access interface.
Works on Python2 and 3.
Usage:
file = File(".bashrc")
file.write("Hello, world!!")
print(file.read())
del file
"""
class Mode:
r = "rb"
w = "wb+"
a = "ab+"
def __init__(self, path, encoding="utf-8"):
self.path = path
self.encoding = encoding
self.mode = None
self._fd = None
def __del__(self):
self.ensure_close()
def __str__(self):
return "<File object: path={}, encoding={} mode={}".format(
self.path, self.encoding, self.mode
)
def __iter__(self):
self.ensure_open(self.Mode.r)
for l in self._fd:
yield PyString(l)
def statinfo(self):
return os.stat(self.path)
def size(self):
return os.stat(self.path).st_size
def top(self):
"""
Usage:
>>> file = File("hello.txt")
>>> print(file.read())
hello, world
>>> print(file.read())
>>> print(file.top())
>>> print(file.read())
hello, world
"""
return self.seek(0)
def end(self):
"""
Usage:
>>> file = File("hello.txt")
>>> print(file.end())
>>> print(file.read())
"""
return self.seek(0, 2)
def seek(self, *args, **kwargs):
"""WIP what about mode?"""
return self._fd.seek(*args, **kwargs)
def truncate(self, *args, **kwargs):
"""WIP How should I work??"""
return self._fd.truncate(*args, **kwargs)
def read(self, *args, **kwargs):
"""
Usage:
>>> file = File("hello.txt")
>>> print(file.read())
hello, world
"""
self.ensure_open(self.Mode.r)
return PyString(self._fd.read(*args, **kwargs))
def readline(self, *args, **kwargs):
self.ensure_open(self.Mode.r)
return PyString(self._fd.readline(*args, **kwargs))
def readlines(self, *args, **kwargs):
self.ensure_open(self.Mode.r)
return (PyString(s) for s in self._fd.readlines(*args, **kwargs))
def write(self, data, *args, **kwargs):
"""
Usage:
>>> file = File("hello.txt")
>>> file.write("hello, world")
>>> print(file.read())
hello, world
"""
self.ensure_open(self.Mode.w)
return self.__write(data, *args, **kwargs)
def writelines(self, seq, *args, **kwargs):
"""
Usage:
>>> file = File("hello.txt")
>>> file.writelines(["hello", "world"])
>>> print(file.read())
hello
world
"""
self.ensure_open(self.Mode.w)
seq = [self.__ensure_nl(line) for line in seq]
return self.__writelines(seq, *args, **kwargs)
def append(self, data, *args, **kwargs):
"""
Usage:
>>> file = File("hello.txt")
>>> print(file.read())
hello
>>> file.append(", world")
>>> print(file.read())
hello, world
"""
self.ensure_open(self.Mode.a)
return self.__write(data, *args, **kwargs)
def appendlines(self, seq, *args, **kwargs):
"""
Usage:
>>> file = File("hello.txt")
>>> print(file.read())
hello
>>> file.appendlines(["world", "!!"])
>>> print(file.read())
hello
world
!!
"""
self.ensure_open(self.Mode.a)
seq = [self.__ensure_nl("")] + [self.__ensure_nl(line) for line in seq]
return self.__writelines(seq, *args, **kwargs)
def open(self, mode, *args, **kwargs):
""" An alias of ensure_open
Usage:
>>> file = File(path, encoding).open(File.Mode.R)
"""
return self.ensure_open(mode, *args, **kwargs)
def close(self, *args, **kwargs):
"""An alias of ensure_close
Usage:
>>> file.close()
"""
self.ensure_close(*args, **kwargs)
def ensure_open(self, mode, *args, **kwargs):
""" Open the file with mode `mode` if not opend.
Usually you don't have to use this method directly.
Use read, write, append,.. methods instead.
Usage:
>>> file.ensure_open(File.Mode.R)
"""
if self._fd and self.mode == mode:
return self
self.mode = mode
self._fd = self.__open(
self.path, mode, *args, **kwargs
)
return self
def ensure_close(self, *args, **kwargs):
"""
Close the file if opened.
Usually you don't have to use this method directly.
Usage:
>>> file.ensure_close()
"""
if not self._fd:
return
self._fd.close(*args, **kwargs)
self._fd = None
self.mode = None
return
def __ensure_nl(self, string):
"""Append new line chars to the end of `string`.
Usage:
>>> assert self.__ensure_nl("") == "\n"
>>> assert self.__ensure_nl("hello") == "hello\n"
"""
if not string.endswith("\n"):
string += "\n"
return string
def __write(self, data, *args, **kwargs):
"""Use this instead of fd.write.
"""
data = PyString(data, self.encoding)
self._fd.write(data.encode(self.encoding), *args, **kwargs)
def __writelines(self, seq, *args, **kwargs):
"""Use this instead of fd.writelines.
"""
seq = [PyString(s, self.encoding).encode(self.encoding) for s in seq]
self._fd.writelines(seq, *args, **kwargs)
def __open(self, *args, **kwargs):
# In python2, open doesn't accept `encoding`.
# In python3, `encoding` cannot be specified on binary mode.
if 'encoding' in kwargs:
del kwargs['encoding']
return open(*args, **kwargs)
|
|
|
|
|
3e727e35fdc429e6a7c905d1f46288b990a809bb
|
|
|
|
Sources/ValueProvider/Miscellanious.swift
|
KizzyCode/persistentstate-swift
|
22566951b25fe6dd5e0a2d109bda1492b9f6d032
|
[
"BSD-2-Clause",
"MIT"
] |
|
|
|
Sources/ValueProvider/Miscellanious.swift
|
KizzyCode/persistentstate-swift
|
22566951b25fe6dd5e0a2d109bda1492b9f6d032
|
[
"BSD-2-Clause",
"MIT"
] |
|
|
|
Sources/ValueProvider/Miscellanious.swift
|
KizzyCode/persistentstate-swift
|
22566951b25fe6dd5e0a2d109bda1492b9f6d032
|
[
"BSD-2-Clause",
"MIT"
] |
|
|
|
import Foundation
/// A type that implements a default constructor
public protocol Default {
/// Creates a new default instance of `Self`
init()
}
/// A mapped value/dictionary ID
public protocol ID {
/// The ID bytes
var bytes: Data { get }
}
extension Data: ID {
public var bytes: Data { self }
}
extension String: ID {
public var bytes: Data { self.data(using: .utf8)! }
}
/// A type that defines methods for encoding
public protocol ValueEncoder {
/// Encodes an instance of the indicated type
///
/// - Parameter value: The instance to encode
func encode<T: Encodable>(_ value: T) throws -> Data
}
extension JSONEncoder: ValueEncoder {}
/// A type that defines methods for decoding
public protocol ValueDecoder {
/// Decodes an instance of the indicated type
///
/// - Parameters:
/// - type: The target type
/// - data: The data to decode
func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T
}
extension JSONDecoder: ValueDecoder {}
|
|
|
|
|
84c5ee02cb1cd393b85356f2a49149b3e3d7c9cc
|
|
|
|
|
|
ecfb9b92e094bfa29102e586ffd615d719b45532
|
|
|
|
|
|
|
ecfb9b92e094bfa29102e586ffd615d719b45532
|
|
|
|
|
|
|
ecfb9b92e094bfa29102e586ffd615d719b45532
|
|
|
|
|
#ifndef NODELIST_H_
#define NODELIST_H_
#include "DataType.h"
class Node{
friend class NodeList; //allows direct accessing of link and data from class NodeList
public:
Node() :
m_next( NULL )
{
}
Node(const DataType & data, Node * next = NULL) :
m_next( next ),
m_data( data )
{
}
Node(const Node & other) :
m_next( other.m_next ),
m_data( other.m_data )
{
}
DataType & data(){ //gets non-const reference, can be used to modify value of underlying data
//return const_cast<DataType &>(static_cast<const Node &>(*this).getData()); //an alternative implementation, just for studying reference
return m_data;
}
const DataType & data() const{ //gets const reference, can be used to access value of underlying data
return m_data;
}
private:
Node * m_next;
DataType m_data;
};
class NodeList{
friend std::ostream & operator<<(std::ostream & os, //(i)
const NodeList & nodeList);
public:
NodeList(); //(1)
NodeList(size_t count, const DataType & value); //(2)
NodeList(const NodeList & other); //(3)
~NodeList(); //(4)
NodeList & operator= (const NodeList & rhs); //(5)
Node * front(); //(6)
Node * back(); //(7)
Node * find(const DataType & target, //(8)
Node * & previous,
const Node * start = NULL);
Node * insertAfter(const DataType & target, //(9)
const DataType & value);
Node * insertBefore(const DataType & target, //(10)
const DataType & value);
Node * erase(const DataType & target); //(11)
DataType & operator[] (size_t position); //(12a)
const DataType & operator[] (size_t position) const; //(12b)
size_t size() const; //(13)
bool empty() const; //(14)
void clear(); //(15)
private:
Node * m_head;
};
#endif //NODELIST_H_
|
|
|
|
|
0a89d3a27590be15490c3a27155eb9c2ff4bd500
|
|
|
|
collaboration-suite-utils/src/main/java/com/kaleyra/collaboration_suite_utils/network_observer/InternetObserver.kt
|
Bandyer/Kaleyra-Android-Collaboration-Suite-Utils
|
216049e9b5e234e441c234e121d689c493591373
|
|
|
|
|
collaboration-suite-utils/src/main/java/com/kaleyra/collaboration_suite_utils/network_observer/InternetObserver.kt
|
Bandyer/Kaleyra-Android-Collaboration-Suite-Utils
|
216049e9b5e234e441c234e121d689c493591373
|
|
|
|
|
collaboration-suite-utils/src/main/java/com/kaleyra/collaboration_suite_utils/network_observer/InternetObserver.kt
|
Bandyer/Kaleyra-Android-Collaboration-Suite-Utils
|
216049e9b5e234e441c234e121d689c493591373
|
|
|
|
|
/*
* Copyright (C) 2022 Kaleyra S.p.a. All Rights Reserved.
* See LICENSE.txt for licensing information
*/
package com.kaleyra.collaboration_suite_utils.network_observer
import android.Manifest
import androidx.annotation.RequiresPermission
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.flow.*
import java.net.HttpURLConnection
import java.net.URL
/**
* Utility class which allows to observe the internet state. It tells if there is actually internet connection.
*/
class InternetObserver @RequiresPermission(Manifest.permission.INTERNET) constructor(private val intervalInMs: Long) {
private val isConnectedFlow: MutableSharedFlow<Boolean> =
MutableSharedFlow(onBufferOverflow = BufferOverflow.DROP_OLDEST, replay = 1)
private var job: Job = CoroutineScope(Dispatchers.IO).launch {
while (true) {
isConnectedFlow.emit(isConnected())
delay(intervalInMs)
}
}
/**
* Call to observe the internet state. It returns true if internet is reachable, false otherwise
*
* @return SharedFlow<Boolean>
*/
fun observe(): Flow<Boolean> = isConnectedFlow.distinctUntilChanged()
/**
* Stop the observer
*/
fun stop() = job.cancel()
private fun isConnected(): Boolean {
var urlConnection: HttpURLConnection? = null
val result = kotlin.runCatching {
urlConnection = initConnection()
urlConnection!!.responseCode == 204
}.getOrNull() ?: false
urlConnection?.disconnect()
return result
}
private fun initConnection() =
(URL(HOST).openConnection() as HttpURLConnection).apply {
connectTimeout = CONNECT_TIMEOUT
readTimeout = READ_TIMEOUT
instanceFollowRedirects = false
useCaches = false
}
private companion object {
const val HOST = "https://clients3.google.com/generate_204"
const val CONNECT_TIMEOUT = 10000
const val READ_TIMEOUT = 10000
}
}
|
|
|
|
|
2f3550f45eaf39f60243ac6016b0a728b6dafd98
|
|
|
|
src/DbAdmin/Traits/TableSelectTrait.php
|
|
fb4389223d1f7ad9aba0cd6e8256c95275942661
|
|
|
|
|
src/DbAdmin/Traits/TableSelectTrait.php
|
|
fb4389223d1f7ad9aba0cd6e8256c95275942661
|
|
|
|
|
src/DbAdmin/Traits/TableSelectTrait.php
|
|
fb4389223d1f7ad9aba0cd6e8256c95275942661
|
|
|
|
|
<?php
namespace Lagdo\DbAdmin\DbAdmin\Traits;
use Lagdo\DbAdmin\Driver\Entity\TableSelectEntity;
use function intval;
use function count;
use function html_entity_decode;
use function strip_tags;
use function array_flip;
use function in_array;
use function substr;
trait TableSelectTrait
{
/**
* Print columns box in select
* @param array $select Result of processSelectColumns()[0]
* @param array $columns Selectable columns
* @param array $options
* @return array
*/
private function getColumnsOptions(array $select, array $columns, array $options): array
{
return [
'select' => $select,
'values' => (array)$options["columns"],
'columns' => $columns,
'functions' => $this->driver->functions(),
'grouping' => $this->driver->grouping(),
];
}
/**
* Print search box in select
*
* @param array $columns Selectable columns
* @param array $indexes
* @param array $options
*
* @return array
*/
private function getFiltersOptions(array $columns, array $indexes, array $options): array
{
$fulltexts = [];
foreach ($indexes as $i => $index) {
$fulltexts[$i] = $index->type == "FULLTEXT" ? $this->util->html($options["fulltext"][$i]) : '';
}
return [
// 'where' => $where,
'values' => (array)$options["where"],
'columns' => $columns,
'indexes' => $indexes,
'operators' => $this->driver->operators(),
'fulltexts' => $fulltexts,
];
}
/**
* Print order box in select
*
* @param array $columns Selectable columns
* @param array $options
*
* @return array
*/
private function getSortingOptions(array $columns, array $options): array
{
$values = [];
$descs = (array)$options["desc"];
foreach ((array)$options["order"] as $key => $value) {
$values[] = [
'col' => $value,
'desc' => $descs[$key] ?? 0,
];
}
return [
// 'order' => $order,
'values' => $values,
'columns' => $columns,
];
}
/**
* Print limit box in select
*
* @param string $limit Result of processSelectLimit()
*
* @return array
*/
private function getLimitOptions(string $limit): array
{
return ['value' => $this->util->html($limit)];
}
/**
* Print text length box in select
*
* @param int $textLength Result of processSelectLength()
*
* @return array
*/
private function getLengthOptions(int $textLength): array
{
return [
'value' => $textLength === 0 ? 0 : $this->util->html($textLength),
];
}
/**
* Print action box in select
*
* @param array $indexes
*
* @return array
*/
// private function getActionOptions(array $indexes)
// {
// $columns = [];
// foreach ($indexes as $index) {
// $current_key = \reset($index->columns);
// if ($index->type != "FULLTEXT" && $current_key) {
// $columns[$current_key] = 1;
// }
// }
// $columns[""] = 1;
// return ['columns' => $columns];
// }
/**
* Print command box in select
*
* @return bool whether to print default commands
*/
// private function getCommandOptions()
// {
// return !$this->driver->isInformationSchema($this->driver->database());
// }
/**
* Print import box in select
*
* @return bool whether to print default import
*/
// private function getImportOptions()
// {
// return !$this->driver->isInformationSchema($this->driver->database());
// }
/**
* Print extra text in the end of a select form
*
* @param array $emailFields Fields holding e-mails
* @param array $columns Selectable columns
*
* @return array
*/
// private function getEmailOptions(array $emailFields, array $columns)
// {
// }
/**
* @param array $queryOptions
*
* @return int
*/
private function setDefaultOptions(array &$queryOptions): int
{
$defaultOptions = [
'columns' => [],
'where' => [],
'order' => [],
'desc' => [],
'fulltext' => [],
'limit' => '50',
'text_length' => '100',
'page' => '1',
];
foreach ($defaultOptions as $name => $value) {
if (!isset($queryOptions[$name])) {
$queryOptions[$name] = $value;
}
}
$page = intval($queryOptions['page']);
if ($page > 0) {
$page -= 1; // Page numbers start at 0 here, instead of 1.
}
$queryOptions['page'] = $page;
return $page;
}
/**
* @param array $fields
*
* @return array
*/
private function getFieldsOptions(array $fields): array
{
$rights = []; // privilege => 0
$columns = []; // selectable columns
$textLength = 0;
foreach ($fields as $key => $field) {
$name = $this->util->fieldName($field);
if (isset($field->privileges["select"]) && $name != "") {
$columns[$key] = html_entity_decode(strip_tags($name), ENT_QUOTES);
if ($this->util->isShortable($field)) {
$textLength = $this->util->processSelectLength();
}
}
$rights[] = $field->privileges;
}
return [$rights, $columns, $textLength];
}
/**
* @param array $indexes
* @param array $select
* @param mixed $tableStatus
*
* @return array
*/
private function setPrimaryKey(array &$indexes, array $select, $tableStatus): array
{
$primary = null;
$unselected = [];
foreach ($indexes as $index) {
if ($index->type == "PRIMARY") {
$primary = array_flip($index->columns);
$unselected = ($select ? $primary : []);
foreach ($unselected as $key => $val) {
if (in_array($this->driver->escapeId($key), $select)) {
unset($unselected[$key]);
}
}
break;
}
}
$oid = $tableStatus->oid;
if ($oid && !$primary) {
/*$primary = */$unselected = [$oid => 0];
$indexes[] = ["type" => "PRIMARY", "columns" => [$oid]];
}
return $unselected;
}
/**
* @param string $table
* @param array $columns
* @param array $fields
* @param array $select
* @param array $group
* @param array $where
* @param array $order
* @param array $unselected
* @param int $limit
* @param int $page
*
* @return TableSelectEntity
*/
private function getSelectEntity(string $table, array $columns, array $fields, array $select,
array $group, array $where, array $order, array $unselected, int $limit, int $page): TableSelectEntity
{
$select2 = $select;
$group2 = $group;
if (empty($select2)) {
$select2[] = "*";
$convert_fields = $this->driver->convertFields($columns, $fields, $select);
if ($convert_fields) {
$select2[] = substr($convert_fields, 2);
}
}
foreach ($select as $key => $val) {
$field = $fields[$this->driver->unescapeId($val)] ?? null;
if ($field && ($as = $this->driver->convertField($field))) {
$select2[$key] = "$as AS $val";
}
}
$isGroup = count($group) < count($select);
if (!$isGroup && !empty($unselected)) {
foreach ($unselected as $key => $val) {
$select2[] = $this->driver->escapeId($key);
if (!empty($group2)) {
$group2[] = $this->driver->escapeId($key);
}
}
}
// From driver.inc.php
return new TableSelectEntity($table, $select2, $where, $group2, $order, $limit, $page);
}
}
|
|
|
|
|
a1e4f9de1a2c3d177810684e3270894543c2d4e4
|
|
|
|
|
Menelau/LOG645-Course-examples
|
ef35b7c10daa2610dd1b4da10658b4acb623d7b4
|
|
|
|
|
|
Menelau/LOG645-Course-examples
|
ef35b7c10daa2610dd1b4da10658b4acb623d7b4
|
|
|
|
|
|
Menelau/LOG645-Course-examples
|
ef35b7c10daa2610dd1b4da10658b4acb623d7b4
|
|
|
|
|
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
long thread_count;
sem_t semaphore;
void* Semaphore_Function(void* args) {
long rank = (long) args;
sem_wait(&semaphore);
printf("Hello from thread %ld.\n", rank);
sleep(10); // simulating intensive calculation...
printf("Thread %ld returning token.\n", rank);
sem_post(&semaphore);
return NULL;
}
int main(int argc, char *argv[]) {
thread_count = strtol(argv[1], NULL, 10);
pthread_t *thread_handles;
thread_handles = malloc(thread_count * sizeof(pthread_t));
// initializing a semaphore with 4 "tokens" or threads that can run in parallel
sem_init(&semaphore, 0, 4);
for (long thread = 0; thread < thread_count; thread++) {
pthread_create(&thread_handles[thread], NULL, &Semaphore_Function, (void*) thread);
}
for (int thread = 0; thread < thread_count; thread++) {
pthread_join(thread_handles[thread], NULL);
}
//destroy semaphore
sem_destroy(&semaphore);
free(thread_handles);
return 0;
}
|
|
|
|
|
163b389e91b9ce381ce43b77bd922f4308b69cbd
|
|
|
|
app/components/menu-bar.component.ts
|
|
df744aa757079074ddff3af8240d2f4905a67c54
|
|
|
|
|
app/components/menu-bar.component.ts
|
|
df744aa757079074ddff3af8240d2f4905a67c54
|
|
|
|
|
app/components/menu-bar.component.ts
|
|
df744aa757079074ddff3af8240d2f4905a67c54
|
|
|
|
|
import {Component, Input, Injectable} from '@angular/core';
import {User} from '../objects/user';
import {DataService} from '../services/data.service';
import {VARIABLES} from '../AppSettings';
@Component({
selector: 'menu-bar',
templateUrl: '../html/menu-bar.component.html',
styleUrls: ['../css/menu-bar.component.css']
})
export class MenuBarComponent {
model: User = new User('yafou');
connected: boolean=false;
constructor(private dataService: DataService) {
}
onSubmit() {
console.log('onSubmit is called ! model=' + this.model);
this.tryConnect(this.model);
}
private tryConnect(model: User) {
if (VARIABLES.MODE_TEST) {
this.connected=true;
this.model = this.retrieveUserInfos();
} else {
//TODO: call backend to check user/pwd and retrieve infos/stories/....
}
}
private retrieveUserInfos(): User {
return this.model;
}
}
|
|
|
|
|
407cc58f6332cad601adf4604b758ab8ec38d70e
|
|
|
|
NVLL/analysis/word_freq.py
|
|
95a39fa9f7a0659e432475e8dfb9a46e305d53b7
|
|
|
|
|
NVLL/analysis/word_freq.py
|
|
95a39fa9f7a0659e432475e8dfb9a46e305d53b7
|
|
|
|
|
NVLL/analysis/word_freq.py
|
|
95a39fa9f7a0659e432475e8dfb9a46e305d53b7
|
|
|
|
|
import os
def count(dic, fname):
with open(fname, 'r') as fd:
lines = fd.read().splitlines()
filtered_sents = []
for l in lines:
words = l.split(" ")
_ratio = comp_unk_ratio(words)
if _ratio <= 0.05:
filtered_sents.append(words)
for w in words:
if w in dic:
dic[w] += 1
else:
dic[w] = 1
return dic, filtered_sents
def read_sent():
pass
def comp_unk_ratio(sent):
total = len(sent) + 0.000001
cnt = 0
for w in sent:
if w == '<unk>':
cnt += 1
return cnt / total
def comp_ratio():
pass
def generate_based_on_word_freq():
count_word_freq()
def generate_based_on_sentiment():
pass
def count_word_freq():
d = {}
os.chdir("../../data/yelp")
d, _ = count(d, "valid.txt")
d, filtered_sents_test = count(d, "test.txt")
sorted_d = sorted(d, key=d.get, reverse=True)
print("Len of trimmed vocab {}".format(len(sorted_d)))
print("Num of Test samples after trimming {}".format(len(filtered_sents_test)))
uncommon = sorted_d[-10000:]
print(uncommon)
divide = 5
every = int(len(filtered_sents_test) / divide)
sent_dictionary = {}
for sent in filtered_sents_test:
total = len(sent)
cnt = 0.
for w in sent:
if w in uncommon:
cnt += 1
sent_dictionary[" ".join(sent)] = cnt / total
sorted_sents = sorted(sent_dictionary, key=sent_dictionary.get, reverse=True)
for piece in range(divide):
start = int(piece * every)
end = int((piece + 1) * every)
tmp_sents = sorted_sents[start:end]
with open("test-rare-" + str(piece) + ".txt", 'w') as fd:
fd.write("\n".join(tmp_sents))
if __name__ == "__main__":
bank_size = 1000
# Generate 2 set of sentences.
# Before beginning
# if a sentence has more than 10% UNK, remove it.
############
# Based on WordFreq Vocab size=15K
# Divide
# Top 1K sample with largest Common Word Ratio (common word= top3K freq word)
# Top 1K sample with largest Uncommon Word Ratio (uncommon word= top3K infreq word)
generate_based_on_word_freq()
############
# Based on Sentiment (sample from 5star and 1star)
#############
|
|
|
|
|
f082f97017dd469928617efda67490dacef988de
|
|
|
|
|
boardingschool/boardingschool.github.io
|
7c8aee829b294bf8ab9f1f02fb7efee5859b0382
|
|
|
|
|
|
boardingschool/boardingschool.github.io
|
7c8aee829b294bf8ab9f1f02fb7efee5859b0382
|
|
|
|
|
|
boardingschool/boardingschool.github.io
|
7c8aee829b294bf8ab9f1f02fb7efee5859b0382
|
|
|
|
|
$(window).load(function() { //start after HTML, images have loaded
var InfiniteRotator =
{
init: function()
{
//initial fade-in time (in milliseconds)
var initialFadeIn = 0;
//interval between items (in milliseconds)
var itemInterval = 5000;
//cross-fade time (in milliseconds)
var fadeTime = 2500;
//count number of items
var numberOfItems = $('.img-item').length;
//set current item
var currentItem = 0;
//show first item
$('.img-item').eq(currentItem).fadeIn(initialFadeIn);
//loop through the items
var infiniteLoop = setInterval(function(){
$('.img-item').eq(currentItem).fadeOut(fadeTime);
if(currentItem == numberOfItems -1){
currentItem = 0;
}else{
currentItem++;
}
$('.img-item').eq(currentItem).fadeIn(fadeTime);
}, itemInterval);
}
};
InfiniteRotator.init();
});
|
|
|
|
|
d272b67bfa1137eb6c3871e24aadb62b6fb72ffa
|
|
|
|
|
|
18f5fc5d2399b14d464066b1754b096ce8db9c2d
|
|
|
|
|
|
|
18f5fc5d2399b14d464066b1754b096ce8db9c2d
|
|
|
|
|
|
|
18f5fc5d2399b14d464066b1754b096ce8db9c2d
|
|
|
|
|
<?php
//
// Modified for PHP7 and MySQLi
//
// This needs php-curl installed
//
include("databaseinfo.php");
//Supress all Warnings/Errors
//error_reporting(0);
$now = time();
//
// Search DB
//
//
//mysqli_select_db ($db, $DB_NAME);
if (!isset($db)) $db=mysqli_connect ($DB_HOST, $DB_USER, $DB_PASS, $DB_NAME);
if (mysqli_connect_errno()) {
printf("Connect failed: %s\n", mysqli_connect_error());
exit();
}
function GetURL($host, $port, $url)
{
$url = "http://$host:$port/$url";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$data = curl_exec($ch);
if (curl_errno($ch) == 0)
{
curl_close($ch);
return $data;
}
curl_close($ch);
return "";
}
function CheckHost($hostname, $port)
{
if (!isset($db)) $db=mysqli_connect ($DB_HOST, $DB_USER, $DB_PASS, $DB_NAME);
global $now;
$xml = GetURL($hostname, $port, "?method=collector");
if ($xml == "") //No data was retrieved? (CURL may have timed out)
{
$failcounter = "failcounter + 1";
echo "fail: ".$failcounter."<br>\n";
}
else
$failcounter = "0";
//Update nextcheck to be 10 minutes from now. The current OS instance
//won't be checked again until at least this much time has gone by.
$next = $now + 600;
mysqli_query($db, "UPDATE hostsregister SET nextcheck = $next," .
" checked = 1, failcounter = " . $failcounter .
" WHERE host = '" . mysqli_real_escape_string($db, $hostname) . "'" .
" AND port = '" . mysqli_real_escape_string($db, $port) . "'");
if ($xml != "")
parse($hostname, $port, $xml);
}
function parse($hostname, $port, $xml)
{
global $now, $db;
if (!isset($db)) $db=mysqli_connect ($DB_HOST, $DB_USER, $DB_PASS, $DB_NAME);
///////////////////////////////////////////////////////////////////////
//
// Search engine sim scanner
//
//
// Load XML doc from URL
//
$objDOM = new DOMDocument();
$objDOM->resolveExternals = false;
//Don't try and parse if XML is invalid or we got an HTML 404 error.
if ($objDOM->loadXML($xml) == False)
return;
//
// Get the region data to update
//
$regiondata = $objDOM->getElementsByTagName("regiondata");
//If returned length is 0, collector method may have returned an error
if ($regiondata->length == 0)
return;
$regiondata = $regiondata->item(0);
//
// Update nextcheck so this host entry won't be checked again until after
// the DataSnapshot module has generated a new set of data to be parsed.
//
$expire = $regiondata->getElementsByTagName("expire")->item(0)->nodeValue;
$next = $now + $expire;
$updater = mysqli_query($db, "UPDATE hostsregister SET nextcheck = $next " .
"WHERE host = '" . mysqli_real_escape_string($db, $hostname) . "' AND " .
"port = '" . mysqli_real_escape_string($db, $port) . "'");
//
// Get the region data to be saved in the database
//
$regionlist = $regiondata->getElementsByTagName("region");
foreach ($regionlist as $region)
{
$regioncategory = $region->getAttributeNode("category")->nodeValue;
//
// Start reading the Region info
//
$info = $region->getElementsByTagName("info")->item(0);
$regionuuid = $info->getElementsByTagName("uuid")->item(0)->nodeValue;
$regionname = $info->getElementsByTagName("name")->item(0)->nodeValue;
$regionhandle = $info->getElementsByTagName("handle")->item(0)->nodeValue;
$url = $info->getElementsByTagName("url")->item(0)->nodeValue;
//
// First, check if we already have a region that is the same
//
$check = mysqli_query($db, "SELECT * FROM regions WHERE regionuuid = '" .
mysqli_real_escape_string($db, $regionuuid) . "'");
if (mysqli_num_rows($check) > 0)
{
mysqli_query($db, "DELETE FROM regions WHERE regionuuid = '" .
mysqli_real_escape_string($db, $regionuuid) . "'");
mysqli_query($db, "DELETE FROM parcels WHERE regionuuid = '" .
mysqli_real_escape_string($db, $regionuuid) . "'");
mysqli_query($db, "DELETE FROM allparcels WHERE regionUUID = '" .
mysqli_real_escape_string($db, $regionuuid) . "'");
mysqli_query($db, "DELETE FROM parcelsales WHERE regionUUID = '" .
mysqli_real_escape_string($db, $regionuuid) . "'");
mysqli_query($db, "DELETE FROM objects WHERE regionuuid = '" .
mysqli_real_escape_string($db, $regionuuid) . "'");
}
$data = $region->getElementsByTagName("data")->item(0);
$estate = $data->getElementsByTagName("estate")->item(0);
$username = $estate->getElementsByTagName("name")->item(0)->nodeValue;
$useruuid = $estate->getElementsByTagName("uuid")->item(0)->nodeValue;
$estateid = $estate->getElementsByTagName("id")->item(0)->nodeValue;
//
// Second, add the new info to the database
//
$sql = "INSERT INTO regions VALUES('" .
mysqli_real_escape_string($db, $regionname) . "','" .
mysqli_real_escape_string($db, $regionuuid) . "','" .
mysqli_real_escape_string($db, $regionhandle) . "','" .
mysqli_real_escape_string($db, $url) . "','" .
mysqli_real_escape_string($db, $username) ."','" .
mysqli_real_escape_string($db, $useruuid) ."')";
mysqli_query($db, $sql);
//
// Start reading the parcel info
//
$parcel = $data->getElementsByTagName("parcel");
foreach ($parcel as $value)
{
$parcelname = $value->getElementsByTagName("name")->item(0)->nodeValue;
$parceluuid = $value->getElementsByTagName("uuid")->item(0)->nodeValue;
$infouuid = $value->getElementsByTagName("infouuid")->item(0)->nodeValue;
$parcellanding = $value->getElementsByTagName("location")->item(0)->nodeValue;
$parceldescription = $value->getElementsByTagName("description")->item(0)->nodeValue;
$parcelarea = $value->getElementsByTagName("area")->item(0)->nodeValue;
$parcelcategory = $value->getAttributeNode("category")->nodeValue;
$parcelsaleprice = $value->getAttributeNode("salesprice")->nodeValue;
$dwell = $value->getElementsByTagName("dwell")->item(0)->nodeValue;
$owner = $value->getElementsByTagName("owner")->item(0);
$owneruuid = $owner->getElementsByTagName("uuid")->item(0)->nodeValue;
// Adding support for groups
$group = $value->getElementsByTagName("group")->item(0);
if ($group != "")
{
$groupuuid = $group->getElementsByTagName("groupuuid")->item(0)->nodeValue;
}
else
{
$groupuuid = "00000000-0000-0000-0000-000000000000";
}
//
// Check bits on Public, Build, Script
//
$parcelforsale = $value->getAttributeNode("forsale")->nodeValue;
$parceldirectory = $value->getAttributeNode("showinsearch")->nodeValue;
$parcelbuild = $value->getAttributeNode("build")->nodeValue;
$parcelscript = $value->getAttributeNode("scripts")->nodeValue;
$parcelpublic = $value->getAttributeNode("public")->nodeValue;
//
// Save
//
//$db=mysqli_connect ($DB_HOST, $DB_USER, $DB_PASSWORD);
$sql = "INSERT INTO allparcels VALUES('" .
mysqli_real_escape_string($db, $regionuuid) . "','" .
mysqli_real_escape_string($db, $parcelname) . "','" .
mysqli_real_escape_string($db, $owneruuid) . "','" .
mysqli_real_escape_string($db, $groupuuid) . "','" .
mysqli_real_escape_string($db, $parcellanding) . "','" .
mysqli_real_escape_string($db, $parceluuid) . "','" .
mysqli_real_escape_string($db, $infouuid) . "','" .
mysqli_real_escape_string($db, $parcelarea) . "' )";
mysqli_query($db,$sql);
if ($parceldirectory == "true")
{
$sql = "INSERT INTO parcels VALUES('" .
mysqli_real_escape_string($db, $regionuuid) . "','" .
mysqli_real_escape_string($db, $parcelname) . "','" .
mysqli_real_escape_string($db, $parceluuid) . "','" .
mysqli_real_escape_string($db, $parcellanding) . "','" .
mysqli_real_escape_string($db, $parceldescription) . "','" .
mysqli_real_escape_string($db, $parcelcategory) . "','" .
mysqli_real_escape_string($db, $parcelbuild) . "','" .
mysqli_real_escape_string($db, $parcelscript) . "','" .
mysqli_real_escape_string($db, $parcelpublic) . "','".
mysqli_real_escape_string($db, $dwell) . "','" .
mysqli_real_escape_string($db, $infouuid) . "','" .
mysqli_real_escape_string($db, $regioncategory) . "')";
mysqli_query($db, $sql);
}
if ($parcelforsale == "true")
{
$sql = "INSERT INTO parcelsales VALUES('" .
mysqli_real_escape_string($db, $regionuuid) . "','" .
mysqli_real_escape_string($db, $parcelname) . "','" .
mysqli_real_escape_string($db, $parceluuid) . "','" .
mysqli_real_escape_string($db, $parcelarea) . "','" .
mysqli_real_escape_string($db, $parcelsaleprice) . "','" .
mysqli_real_escape_string($db, $parcellanding) . "','" .
mysqli_real_escape_string($db, $infouuid) . "', '" .
mysqli_real_escape_string($db, $dwell) . "', '" .
mysqli_real_escape_string($db, $estateid) . "', '" .
mysqli_real_escape_string($db, $regioncategory) . "')";
mysqli_query($db, $sql);
}
}
//
// Handle objects
//
$objects = $data->getElementsByTagName("object");
foreach ($objects as $value)
{
$uuid = $value->getElementsByTagName("uuid")->item(0)->nodeValue;
$regionuuid = $value->getElementsByTagName("regionuuid")->item(0)->nodeValue;
$parceluuid = $value->getElementsByTagName("parceluuid")->item(0)->nodeValue;
$location = $value->getElementsByTagName("location")->item(0)->nodeValue;
$title = $value->getElementsByTagName("title")->item(0)->nodeValue;
$description = $value->getElementsByTagName("description")->item(0)->nodeValue;
$flags = $value->getElementsByTagName("flags")->item(0)->nodeValue;
mysqli_query($db, "INSERT INTO objects VALUES('" .
mysqli_real_escape_string($db, $uuid) . "','" .
mysqli_real_escape_string($db, $parceluuid) . "','" .
mysqli_real_escape_string($db, $location) . "','" .
mysqli_real_escape_string($db, $title) . "','" .
mysqli_real_escape_string($db, $description) . "','" .
mysqli_real_escape_string($db, $regionuuid) . "')");
}
}
}
$sql = "SELECT host, port FROM hostsregister " .
"WHERE nextcheck < $now AND checked = 0 LIMIT 0,10";
$jobsearch = mysqli_query($db,$sql);
//
// If the sql query returns no rows, all entries in the hostsregister
// table have been checked. Reset the checked flag and re-run the
// query to select the next set of hosts to be checked.
//
if (mysqli_num_rows($jobsearch) == 0)
{
mysqli_query($db, "UPDATE hostsregister SET checked = 0");
$jobsearch = mysqli_query($db,$sql);
}
while ($jobs = mysqli_fetch_row($jobsearch))
CheckHost($jobs[0], $jobs[1]);
?>
|
|
|
|
|
c7cfca04a6d46c8657fca251fdef016d7c180a06
|
|
|
|
|
FranciscoCharles/doom-fire-simulator
|
fccd45e5c96d37de00a6979ec00a5e13a668d4d9
|
|
|
|
|
|
FranciscoCharles/doom-fire-simulator
|
fccd45e5c96d37de00a6979ec00a5e13a668d4d9
|
|
|
|
|
|
FranciscoCharles/doom-fire-simulator
|
fccd45e5c96d37de00a6979ec00a5e13a668d4d9
|
|
|
|
|
#_*_coding:utf-8_*_
#created by FranciscoCharles in april,2021.
from os import environ
if 'PYGAME_HIDE_SUPPORT_PROMPT' not in environ:
environ['PYGAME_HIDE_SUPPORT_PROMPT'] = 'hidden'
del environ
import pygame
import colorsys
import numpy as np
from menu import Menu, HslColor
from fire import FireColorArray
from random import randint
from typing import Tuple, List, Optional, NewType
RgbColor = Tuple[int,int,int]
def rgb_to_float(r:int, g:int, b:int) ->[HslColor]:
return (r/255, g/255, b/255)
def rgb_to_int(r:int, g:int, b:int) -> RgbColor:
return (int(r*255), int(g*255), int(b*255))
class DoomFireSimulator:
def __init__(self) -> None:
pygame.init()
pygame.font.init()
self.SCREEN_W = 830
self.SCREEN_H = 480
pygame.display.set_caption('FireDoomSimaltor v1.0.1')
self.display = pygame.display.set_mode((self.SCREEN_W,self.SCREEN_H))
icon = pygame.image.load('images/icon32.png')
pygame.display.set_icon(icon)
self.clock = pygame.time.Clock()
self.FPS = 20
self.on_fire = True
self.fire_size = (8,8)
self.fire_x = 40
self.fire_y = 40
self.decay_value = 3
self.wind_force = 7
self.wind_mi_force = 0
self.colors = self.selectColorPalette()
self.fire_array = FireColorArray(40,50)
self.setBaseFlameValue(len(self.colors)-1)
self.menu = Menu(len(self.colors)-1)
def selectColorPalette(self, options: Optional[HslColor] = None) -> List[RgbColor]:
self.colors = [
(7,7,7),(31,7,7),(47,15,7),(71,15,7),(87,23,7),(103,31,7),(119,31,7),(143,39,7),(159,47,7),(175,63,7),
(191,71,7),(199,71,7),(223,79,7),(223,87,7),(223,87,7),(215,95,7),(215,95,7),(215,103,15),(207,111,15),
(207,119,15),(207,127,15),(207,135,23),(199,135,23),(199,143,23),(199,151,31),(191,159,31),(191,159,31),
(191,167,39),(191,167,39),(191,175,47),(183,175,47),(183,183,47),(183,183,55),(207,207,111),(223,223,159),
(239,239,199),(255,255,255)]
if isinstance(options, tuple) and len(options)==3:
(shift_color, decay_l,decay_s) = options
shift_color = (shift_color%360)/360
result = []
for cor in self.colors:
cor = rgb_to_float(*cor)
(_,l,s) = colorsys.rgb_to_hls(*cor)
cor = colorsys.hls_to_rgb(shift_color, decay_l*l, decay_s*s)
result.append(rgb_to_int(*cor))
self.colors = result
return self.colors
def setBaseFlameValue(self, value: int) -> None:
row,columns = self.fire_array.shape
row -= 1
for column in range(columns):
self.fire_array[row,column] = value
def updatePixelFire(self, row: int, column: int) -> None:
decay = randint(0, self.decay_value)
shift = column + randint(self.wind_mi_force, self.wind_force)
self.fire_array[row, shift] = (self.fire_array[row+1, column]-decay)
if self.fire_array[row, shift]<0:
self.fire_array[row, shift] = 0
return shift
def evaporateFire(self) -> None:
rows,columns = self.fire_array.shape
for row in range(rows-1):
for column in range(columns):
self.updatePixelFire(row, column)
def drawFire(self) -> None:
rows,columns = self.fire_array.shape
w,h = self.fire_size
for row in range(rows):
for column in range(columns):
color = self.fire_array[row,column]
rect = (self.fire_x+column*w,self.fire_y+row*h,w,h)
pygame.draw.rect(self.display, self.colors[color], rect)
self.evaporateFire()
@property
def rectFire(self) -> Tuple[int,int,int,int]:
h,w = self.fire_array.shape
return (self.fire_x, self.fire_y, w*self.fire_size[0], h*self.fire_size[1])
def run(self) -> None:
ticks = 0
game = True
draw_menu = True
valid_keys = ['q','w','a','s','z','left','right','up','down']
key_pressed = ''
(x,y,w,h) = self.rectFire
fire_rect = (x-1, y-1, w+2, h+2)
rect_menu = (399, 39, 392, 402)
positions = self.menu.getListPositionMenu(620, 94)
pygame.draw.rect(self.display, (0xaaaaaa), fire_rect, 1)
while game:
self.clock.tick(self.FPS)
for e in pygame.event.get():
if e.type == pygame.QUIT:
game = False
break
elif e.type == pygame.KEYDOWN:
key = pygame.key.name(e.key)
if key == 'escape':
game = False
break
elif key in valid_keys:
ticks = pygame.time.get_ticks()
key_pressed = key
getattr(self, key_pressed)()
draw_menu = True
elif e.type == pygame.KEYUP:
key_pressed = ''
if key_pressed and (pygame.time.get_ticks()-ticks)>500:
getattr(self, key_pressed)()
draw_menu = True
if game:
if draw_menu:
pygame.draw.rect(self.display, (0), rect_menu)
self.menu.draw(self.display, positions)
pygame.draw.rect(self.display, (0xaaaaaa), rect_menu, 1)
pygame.display.update(rect_menu)
draw_menu = False
self.drawFire()
pygame.display.update(fire_rect)
self.stop()
def changePalette(self) -> None:
color = None
if self.menu['color intensity']['value']:
color = self.menu.currentColorValue()
self.selectColorPalette(color)
def updateSimulationValues(self) -> None:
name = self.menu.name
if name=='FPS':
self.FPS = self.menu['FPS']['value']
elif name=='decay':
self.decay_value = self.menu['decay']['value']
elif name=='wind direction':
type_index = self.menu['wind direction']['value']
type_value = self.menu['wind direction']['types'][type_index]
wind_force = self.menu['wind force']['value']
if type_value=='left':
self.wind_mi_force = 0
self.wind_force = wind_force
elif type_value=='right':
self.wind_mi_force = -wind_force
self.wind_force = 0
else:
self.wind_force = wind_force
self.wind_mi_force = -wind_force
elif name=='wind force':
self.wind_force = self.menu['wind force']['value']
elif name in ['H','S','L','color intensity']:
self.changePalette()
def left(self) -> None:
self.menu.decrement()
self.updateSimulationValues()
def right(self) -> None:
self.menu.increment()
self.updateSimulationValues()
def up(self) -> None:
self.menu.up()
def down(self) -> None:
self.menu.down()
def a(self) -> None:
self.left()
def s(self) -> None:
self.right()
def w(self) -> None:
self.up()
def z(self) -> None:
self.down()
def q(self) -> None:
self.on_fire = not self.on_fire
self.setBaseFlameValue((len(self.colors)-1) if self.on_fire else 0)
def stop(self) -> None:
pygame.quit()
if __name__ == '__main__':
DoomFireSimulator().run()
|
|
|
|
|
332ec3ad83ab42693d9db460bc909a8573da26d4
|
|
|
|
src/model/synapses/numba_backend/VoltageJump.py
|
|
4463e7d5a5844c8002f7e3d01b4fadc3a20e2038
|
|
|
|
|
src/model/synapses/numba_backend/VoltageJump.py
|
|
4463e7d5a5844c8002f7e3d01b4fadc3a20e2038
|
|
|
|
|
src/model/synapses/numba_backend/VoltageJump.py
|
|
4463e7d5a5844c8002f7e3d01b4fadc3a20e2038
|
|
|
|
|
"""
Created on 12:39, June. 4th, 2021
Author: fassial
Filename: VoltageJump.py
"""
import brainpy as bp
__all__ = [
"VoltageJump",
]
class VoltageJump(bp.TwoEndConn):
target_backend = ['numpy', 'numba', 'numba-parallel', 'numba-cuda']
def __init__(self, pre, post, conn,
weight = 1., delay = 0., **kwargs
):
# init params
self.weight = weight
self.delay = delay
# init connections
self.conn = conn(pre.size, post.size)
self.pre_ids, self.post_ids = self.conn.requires("pre_ids", "post_ids")
self.size = len(self.pre_ids)
# init vars
self.Isyn = self.register_constant_delay("Isyn",
size = self.size,
delay_time = self.delay
)
# init super
super(VoltageJump, self).__init__(pre = pre, post = post, **kwargs)
def update(self, _t):
# set post.V
for i in range(self.size):
pre_id, post_id = self.pre_ids[i], self.post_ids[i]
self.Isyn.push(i,
self.pre.spike[pre_id] * self.weight
)
if not self.post.refractory[post_id]:
self.post.V[post_id] += self.Isyn.pull(i)
|
|
|
|
|
fea027e63c8ec137410b07cae121edd763bbcdf7
|
|
|
|
buildSrc/src/main/kotlin/MarkdownUtil.kt
|
StanleyProjects/AndroidExtension.UserInterface
|
245a7c3c8f7518ddcf17f02629b01404800852da
|
|
|
|
|
buildSrc/src/main/kotlin/MarkdownUtil.kt
|
StanleyProjects/AndroidExtension.UserInterface
|
245a7c3c8f7518ddcf17f02629b01404800852da
|
|
|
|
|
buildSrc/src/main/kotlin/MarkdownUtil.kt
|
StanleyProjects/AndroidExtension.UserInterface
|
245a7c3c8f7518ddcf17f02629b01404800852da
|
|
|
|
|
object MarkdownUtil {
fun url(
text: String,
value: String
): String {
return "[$text]($value)"
}
fun image(
text: String,
url: String
): String {
return "!" + url(text = text, value = url)
}
fun table(
heads: List<String>,
dividers: List<String>,
rows: List<List<String>>
): String {
require(heads.size > 1) { "Size of heads must be more than 1!" }
require(heads.size == dividers.size) {
"Size of heads and size of dividers must be equal!"
}
val firstRow = rows.firstOrNull()
requireNotNull(firstRow) { "Rows must be exist!" }
for (i in 1 until rows.size) {
require(firstRow.size == rows[i].size) {
"Size of columns in all rows must be equal!"
}
}
require(heads.size == firstRow.size) {
"Size of heads and size of rows must be equal!"
}
val result = mutableListOf(
heads.joinToString(separator = "|"),
dividers.joinToString(separator = "|")
)
result.addAll(rows.map { it.joinToString(separator = "|") })
return result.joinToString(separator = SystemUtil.newLine)
}
}
|
|
|
|
|
4e0cf10ba62a61bbde206ff0ae503fbef4c0c6dc
|
|
|
|
Microcontroller_Lab/Lab_6/Lab_6/Read_Code_With_Comments.asm
|
MuhammadAlBarham/pic16f778_projects
|
c12e15e48a62cd16f869cbe9411728a4eea8f499
|
|
|
|
|
Microcontroller_Lab/Lab_6/Lab_6/Read_Code_With_Comments.asm
|
MuhammadAlBarham/pic16f778_projects
|
c12e15e48a62cd16f869cbe9411728a4eea8f499
|
|
|
|
|
Microcontroller_Lab/Lab_6/Lab_6/Read_Code_With_Comments.asm
|
MuhammadAlBarham/pic16f778_projects
|
c12e15e48a62cd16f869cbe9411728a4eea8f499
|
|
|
|
|
Include "p16F84A.inc"
; ----------------------------------------------------------
; General Purpose RAM Assignments
; ----------------------------------------------------------
cblock 0x0C
Counter
Endc
; ----------------------------------------------------------
; Macro Definitions
; ----------------------------------------------------------
Read_EEPROM macro
Bcf STATUS, RP0 ;Go to Bank 0
Clrf EEADR ;Clear EEADR (EEADR=0)
Bsf STATUS, RP0 ;Go to Bank 1
Bsf EECON1, RD ;Begin Read
Bcf STATUS, RP0 ;Go to Bank 0
Endm
; ----------------------------------------------------------
; Vector definition
; ----------------------------------------------------------
org 0x000
nop
goto Main
INT_Routine org 0x004
goto INT_Routine
; ----------------------------------------------------------
; The main Program
; ----------------------------------------------------------
Main
Read_EEPROM
Clrf Counter ;Clear the counter
Bsf STATUS, RP0 ;Go to Bank 1
Clrf TRISB ;Make PORTB as OUTPUT
Bcf STATUS, RP0 ;Go to BANK 0
Movlw A'H' ;Move Character to W-Reg
Subwf EEDATA,w ;Check If the first char. is H
Btfsc STATUS,Z ;If Yes goto finish
Goto Finish
Incf Counter,f
Movlw A'M'
Subwf EEDATA,w
Btfsc STATUS,Z
Finish
Incf Counter,f
Call Look_Up
Movwf PORTB
Loop
Goto Loop
; ----------------------------------------------------------
; Sub Routine Definitions
; ----------------------------------------------------------
;This Look_Up table for 7-Seg. Display
Look_Up
Movf Counter,w
Addwf PCL,f
Retlw B'00111111' ; Number 0
Retlw B'00000110' ; Number 1
Retlw B'01011011' ; Number 2
Retlw B'01001111' ; Number 3
Retlw B'01100110' ; Number 4
Retlw B'01101101' ; Number 5
end
|
|
|
|
|
fdaf633a2d6691a5cac79970a134936e25b5c10c
|
|
|
|
src/scripts/client/gameplay/viz_handlers/flash_units.lua
|
Psimage/Lovely-Camera-Mod
|
7ecb1c354c3e00091ef6005d53eb19d0fcf7f56e
|
|
|
|
|
src/scripts/client/gameplay/viz_handlers/flash_units.lua
|
Psimage/Lovely-Camera-Mod
|
7ecb1c354c3e00091ef6005d53eb19d0fcf7f56e
|
|
|
|
|
src/scripts/client/gameplay/viz_handlers/flash_units.lua
|
Psimage/Lovely-Camera-Mod
|
7ecb1c354c3e00091ef6005d53eb19d0fcf7f56e
|
|
|
|
|
----------------------------------------------------------------
-- Copyright (c) 2012 Klei Entertainment Inc.
-- All Rights Reserved.
-- SPY SOCIETY.
----------------------------------------------------------------
local viz_thread = include( "gameplay/viz_thread" )
local array = include( "modules/array" )
local cdefs = include( "client_defs" )
local util = include( "client_util" )
local simdefs = include( "sim/simdefs" )
local simquery = include( "sim/simquery" )
---------------------------------------------------------------
local flash_units = class( viz_thread )
function flash_units:init( boardrig, viz, rig, duration )
viz_thread.init( self, viz, self.onResume )
viz:registerHandler( simdefs.EV_FRAME_UPDATE, self )
self.boardrig = boardrig
self.rig = rig
self.duration = duration
--move rig from layers["main"] to layers["ceiling"]
--increment usage_count and enable fullscreen darkening overlay if 1
local rigProp = rig:getProp()
local main = boardrig._layers["main"]
local ceiling = boardrig._layers["ceiling"]
main:removeProp( rigProp )
ceiling:insertProp( rigProp )
rigProp:setPriority( 110000 )
if not boardrig._flashThreadCount or boardrig._flashThreadCount == 0 then
boardrig._flashThreadCount = 1
--print( "inserting dimmer" )
--local bSoundPlayed = false
local timer = MOAITimer.new()
timer:setSpan( duration / (60*2) )
timer:setMode( MOAITimer.PING_PONG )
timer:start()
local uniformDriver = function( uniforms )
local t = timer:getTime() / (duration / (60*2) )
t = math.min(0.7,t*3)
uniforms:setUniformFloat( "ease", t )
--print('dimmer ease', t )
end
local uniforms = KLEIShaderUniforms.new()
uniforms:setUniformDriver( uniformDriver )
local dimmerProp = KLEIFullscreenProp.new()
dimmerProp:setShader( MOAIShaderMgr.getShader( MOAIShaderMgr.KLEI_POST_PROCESS_PASS_THROUGH_EASE ) )
dimmerProp:setShaderUniforms( uniforms )
dimmerProp:setTexture( "data/images/the_darkness.png" )
dimmerProp:setBlendMode( MOAIProp.BLEND_NORMAL )
dimmerProp:setPriority( 100000 )
ceiling:insertProp( dimmerProp )
boardrig._dimmerProp = dimmerProp
else
boardrig._flashThreadCount = boardrig._flashThreadCount + 1
end
end
function flash_units:onStop()
self.rig:refreshRenderFilter()
--move rig from layers["ceiling"] to layers["main"]
--decrement usage_count and disable fullscreen darkening overlay if 0
local rigProp = self.rig:getProp()
local main = self.boardrig._layers["main"]
local ceiling = self.boardrig._layers["ceiling"]
ceiling:removeProp( rigProp )
main:insertProp( rigProp )
local count = self.boardrig._flashThreadCount - 1
self.boardrig._flashThreadCount = count
if count <= 0 then
--print( "deleting dimmer" )
local dimmerProp = self.boardrig._dimmerProp
ceiling:removeProp( dimmerProp )
self.boardrig._dimmerProp = nil
end
end
function flash_units:onResume( ev )
while self.duration > 0 do
if self.duration % 20 == 0 then
self.rig:getProp():setRenderFilter( cdefs.RENDER_FILTERS["focus_highlite"] )
elseif self.duration % 10 == 0 then
self.rig:refreshRenderFilter()
end
self.duration = self.duration - 1
coroutine.yield()
end
end
return flash_units
|
|
|
|
|
da1f4b82540846bf3b10497980830f102e02fe01
|
|
|
|
resources/[scripts]/[hoppe]/[jobs]/hpp_cet/towtruck.lua
|
|
acc33ae5032fb2488dacfa49046470feb8cac32e
|
|
|
|
|
resources/[scripts]/[hoppe]/[jobs]/hpp_cet/towtruck.lua
|
|
acc33ae5032fb2488dacfa49046470feb8cac32e
|
|
|
|
|
resources/[scripts]/[hoppe]/[jobs]/hpp_cet/towtruck.lua
|
|
acc33ae5032fb2488dacfa49046470feb8cac32e
|
|
|
|
|
RegisterCommand("towtruck", function()
vehicle = GetVehiclePedIsUsing(GetPlayerPed(-1))
vehicletow = GetDisplayNameFromVehicleModel(GetEntityModel(GetVehiclePedIsUsing(GetPlayerPed(-1))))
end)
local reboque = nil
local rebocado = nil
RegisterCommand("tow",function(source,args)
--local vehicle = GetPlayersLastVehicle()
--local vehicletow = IsVehicleModel(vehicle,GetHashKey("flatbed"))
if vehicletow and not IsPedInAnyVehicle(PlayerPedId()) then
--rebocado = getVehicleInDirection(GetEntityCoords(PlayerPedId()),GetOffsetFromEntityInWorldCoords(PlayerPedId(),0.0,5.0,0.0))
rebocado = GetPlayersLastVehicle()
if reboque == nil then
if vehicle ~= rebocado then
local min,max = GetModelDimensions(GetEntityModel(rebocado))
AttachEntityToEntity(rebocado,vehicle,GetEntityBoneIndexByName(vehicle,"bodyshell"),0,-2.2,0.4-min.z,0,0,0,1,1,0,1,0,1)
reboque = rebocado
end
else
AttachEntityToEntity(reboque,vehicle,20,-0.5,-15.0,-0.3,0.0,0.0,0.0,false,false,true,false,20,true)
DetachEntity(reboque,false,false)
PlaceObjectOnGroundProperly(reboque)
reboque = nil
rebocado = nil
end
end
end)
Citizen.CreateThread(function()
while true do
Citizen.Wait(0)
if enablemechud then
if vehicletow == nil then
vehicletow = "NENHUM"
end
rebocado = GetDisplayNameFromVehicleModel(GetEntityModel(GetPlayersLastVehicle()))
if rebocado == nil then
rebocado = "NENHUM"
elseif rebocado == "FLATBED" then
rebocado = "NENHUM"
end
--print(vehicletow)
--print(rebocado)
if vehicletow ~= "FLATBED" then
drawTxt("REBOQUE:~r~"..vehicletow,4,0.5,0.93,0.50,255,255,255,255)
elseif vehicletow == "FLATBED" then
drawTxt("REBOQUE:~g~"..vehicletow,4,0.5,0.93,0.50,255,255,255,255)
end
drawTxt("REBOCADO:~r~"..rebocado,4,0.5,0.96,0.50,255,255,255,255)
end
end
end)
enablemechud = false
RegisterCommand("towhud", function()
if not enablemechud then
enablemechud = true
elseif enablemechud then
enablemechud = false
end
end)
|
|
|
|
|
b89f9543ecb27486610847a26f0dea237fce7656
|
|
|
|
|
|
ab2c4228229988d79ba7a9034069961650830031
|
|
|
|
|
|
|
ab2c4228229988d79ba7a9034069961650830031
|
|
|
|
|
|
|
ab2c4228229988d79ba7a9034069961650830031
|
|
|
|
|
use aoc::solver::Solver;
pub struct Day25;
#[derive(Copy, Clone)]
enum Cell {
Empty,
East,
South,
}
struct Grid {
width: usize,
height: usize,
value: Vec<Cell>,
}
impl Grid {
fn new(data: &str) -> Self {
let width = data.lines().next().unwrap().trim().len();
let mut grid = Grid {
width,
height: 0,
value: Vec::new(),
};
for line in data.lines() {
for c in line.trim().chars() {
grid.value.push(match c {
'>' => Cell::East,
'v' => Cell::South,
_ => Cell::Empty,
});
}
}
grid.height = grid.value.len() / width;
grid
}
fn east(&self, n: usize) -> usize {
if n % self.width == self.width - 1 {
n + 1 - self.width
} else {
n + 1
}
}
fn south(&self, n: usize) -> usize {
if n >= (self.height - 1) * self.width {
n % self.width
} else {
n + self.width
}
}
fn step(&self) -> (usize, Self) {
let mut count = 0;
let mut grid = Grid {
width: self.width,
height: self.height,
value: Vec::new(),
};
grid.value.resize(self.width * self.height, Cell::Empty);
for (n, v) in self.value.iter().enumerate() {
if matches!(v, Cell::East) {
let target = self.east(n);
if matches!(self.value[target], Cell::Empty) {
grid.value[target] = Cell::East;
count += 1;
} else {
grid.value[n] = Cell::East;
}
}
}
for (n, v) in self.value.iter().enumerate() {
if matches!(v, Cell::South) {
let target = self.south(n);
if matches!(grid.value[target], Cell::Empty)
&& !matches!(self.value[target], Cell::South)
{
grid.value[target] = Cell::South;
count += 1;
} else {
grid.value[n] = Cell::South;
}
}
}
(count, grid)
}
}
impl std::fmt::Display for Cell {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(
f,
"{}",
match self {
Cell::Empty => '.',
Cell::East => '>',
Cell::South => 'v',
}
)
}
}
impl std::fmt::Display for Grid {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut n = 0;
let mut result = String::new();
for _ in 0..self.height {
for _ in 0..self.width {
let line = format!("{}", self.value[n]);
n += 1;
result.push_str(&line);
}
result.push('\n');
}
write!(f, "{}", result)
}
}
impl Solver<&str> for Day25 {
fn part1(data: &str) -> usize {
let mut count = 0;
let mut grid = Grid::new(data);
loop {
let result = grid.step();
count += 1;
if result.0 == 0 {
break;
}
grid = result.1;
}
count
}
fn part2(_data: &str) -> usize {
0
}
}
#[cfg(test)]
mod tests {
use super::*;
const DATA: &str = "v...>>.vv>
.vv>>.vv..
>>.>v>...v
>>v>>.>.v.
v>v.vv.v..
>.>>..v...
.vv..>.>v.
v.v..>>v.v
....v..v.>
";
#[test]
fn test_part1() {
assert_eq!(Day25::part1(DATA), 58);
}
#[test]
fn test_part2() {
assert_eq!(Day25::part2(DATA), 0);
}
}
|
|
|
|
|
b156345f812e80c4199551982bf4bc47bc72fad8
|
|
|
|
sorce/mikey/Opera/Grass.h
|
|
3469747603dfead376111f38b455af1250365848
|
|
|
|
|
sorce/mikey/Opera/Grass.h
|
|
3469747603dfead376111f38b455af1250365848
|
|
|
|
|
sorce/mikey/Opera/Grass.h
|
|
3469747603dfead376111f38b455af1250365848
|
|
|
|
|
struct BistaTranz {
float squl, squr;
bool state;
BistaTranz (){squl=squr=0;}
float calx(float fmm, float den) {
if (state) {
squl += fmm;
if (squl >= den) {
squr = -den;
state = !state;
}
} else {
squr += fmm;
if (squr >= den) {
squl = -den;
state = !state;
}
} return squl;
}
};
struct Bista : Opero {
BistaTranz bt;
shOpr mul, add, fmo, den;
Bista(lua_State *L): Opero() {
broinger(L, 1, "fre", &fmo);
broinger(L, 2, "den", &den, 1.0);
broinger(L, 3, "mul", &mul,1.0);
broinger(L, 4, "add", &add);
}
float calx(float sr) {
mint = 0;
float fmm = 4*fmo->calx(sr)/sr;
float deno = fabs(den->calx(sr));
bt.calx(fmm,deno);
mint = bt.squr * mul->calx(sr) + add->calx(sr);
return mint;
}
static const char className[];
const char * getClassName() { return className; }
};
const char Bista::className[] = "Bista";
struct RunglTranz {
unsigned char pattern;
float mint;
float lastcar;
RunglTranz(){pattern=rand();}
float calx(bool car, bool mod) {
if (car && !lastcar)
pattern = (pattern << 1) | (mod ? 1 : 0);
lastcar = car;
//printf("patternfloat%d\n",pattern);
mint = (float)pattern / 256;
return mint;
}
};
struct Grass : Opero {
BistaTranz square[4];
RunglTranz castle[4];
static const char className[];
shOpr mul, add, fmo, cha;
Grass(lua_State *L): Opero() {
broinger(L, 1, "fre", &fmo);
broinger(L, 2, "cha", &cha);
broinger(L, 3, "mul", &mul,1.0);
broinger(L, 4, "add", &add);
}
float calx(float sr) {
mint = 0;
float chaos = cha->calx(sr);
//printf("chaos%f\n",chaos);
float fmm = 4*fmo->calx(sr)/sr;
for (int i = 0; i < 4; i++) {
square[i].calx(
fmm*(1+chaos*castle[i].calx(
square[(i+2)%4].state, square[(i+1)%4].state)),
1+(float)i/10);
}
float mullo = mul->calx(sr);
mint = square[0].squl*mullo + add->calx(sr);
return mint;
}
const char * getClassName() { return className; }
};
const char Grass::className[] = "Grass";
|
|
|
|
|
ef53113206ffe662ae977a2dee15a9f65785ecd4
|
|
|
|
home/lib/python/exemple/plgrader/one.pls
|
PremierLangage/premierlangage
|
7134a2aadffee2bf264abee6c4b23ea33f1b390b
|
|
|
|
|
apps/misc_tests/resources/lib/python/exemple/plgrader/one.pls
|
PremierLangage/premierlangage
|
7134a2aadffee2bf264abee6c4b23ea33f1b390b
|
|
|
|
|
apps/misc_tests/resources/lib/python/exemple/plgrader/one.pls
|
PremierLangage/premierlangage
|
7134a2aadffee2bf264abee6c4b23ea33f1b390b
|
|
|
|
|
from playexo.strategy import StrategyAPI
def get_last_answered_index(request, activity):
strat = StrategyAPI(activity)
pls = strat.get_pl_list()
i = 0
for pl in pls:
if not strat.get_last_good_answer(pl, request):
return i
i += 1
return 0
def strategy(request, activity):
""" Process request to determine what do to. Should return an HttpResponse. """
strat = StrategyAPI(activity)
current = get_last_answered_index(request, activity)
if request.method == 'GET': # Request changing which exercise will be loaded
action = request.GET.get("action", None)
if action == "pl":
strat.set_pl(strat.get_pl_sha1(request.GET.get("pl_sha1", None)), request)
return HttpResponseRedirect("/playexo/activity/") # Remove get parameters from url
elif action == "pltp":
pl = strat.get_current_pl(request)
if (pl):
can_do = pl.sha1;
strat.set_pl(None, request)
dic = strat.get_pl_dic(strat.get_current_pl(request))
if 'oneshot' in dic and dic['oneshot'] == 'True':
seed = None
else:
seed = strat.get_seed_from_answer(strat.get_last_answer(strat.get_current_pl(request), request))
exercise = strat.load_exercise(request, seed)
if request.method == 'GET': # Request changing or interacting an exercise
if action == "reset":
strat.reset_pl(exercise)
elif action == "next":
pl = strat.get_next_pl(request)
strat.set_pl(pl, request)
return HttpResponseRedirect("/playexo/activity/") # Remove get parameters from url
if request.method == 'POST':
state, feedback = strat.evaluate(exercise, request)
return strat.send_evaluate_feedback(state, feedback)
strat.add_to_context(exercise, 'current_auth', current)
return strat.render(exercise, request)
|
|
|
|
|
8c1cd1193490b6043dceafbc312e302e08e02328
|
|
|
|
java-time/src/main/kotlin/com/github/debop/javatimes/PeriodExtensions.kt
|
|
cbb0efedaa53bdf9d77b230d8477cb0ae0d7abd7
|
[
"ECL-2.0",
"Apache-2.0"
] |
|
|
|
java-time/src/main/kotlin/com/github/debop/javatimes/PeriodExtensions.kt
|
|
cbb0efedaa53bdf9d77b230d8477cb0ae0d7abd7
|
[
"ECL-2.0",
"Apache-2.0"
] |
|
|
|
java-time/src/main/kotlin/com/github/debop/javatimes/PeriodExtensions.kt
|
|
cbb0efedaa53bdf9d77b230d8477cb0ae0d7abd7
|
[
"ECL-2.0",
"Apache-2.0"
] |
|
|
|
package com.github.debop.javatimes
import java.time.Period
import java.time.temporal.Temporal
operator fun Period.unaryMinus(): Period = this.negated()
@Suppress("UNCHECKED_CAST")
operator fun <T : Temporal> Period.plus(instant: T): T = addTo(instant) as T
@Suppress("UNCHECKED_CAST")
operator fun <T : Temporal> Period.minus(instant: T): T = subtractFrom(instant) as T
@JvmOverloads
fun periodOf(years: Int, months: Int = 0, days: Int = 0): Period = Period.of(years, months, days)
/**
* year sequence of `Period`
*/
suspend fun Period.yearSequence(): Sequence<Int> = sequence {
var year = 0
val years = [email protected]
if(years > 0) {
while(year < years) {
yield(year++)
}
} else {
while(year > years) {
yield(year--)
}
}
}
/**
* month sequence of `java.time.Period`
*/
suspend fun Period.monthSequence(): Sequence<Int> = sequence {
var month = 0
val months = [email protected]
if(months > 0) {
while(month < months) {
yield(month++)
}
} else {
while(month > months) {
yield(month--)
}
}
}
/**
* day sequence of `java.time.Period`
*/
suspend fun Period.daySequence(): Sequence<Int> = sequence {
var day = 0
val days = [email protected]
if(days > 0) {
while(day < days) {
yield(day++)
}
} else {
while(day > days) {
yield(day--)
}
}
}
|
|
|
|
|
27e0e1bdc49eab4fdb1dfb4431fe18bd1c9bc125
|
|
|
|
app/src/main/java/com/starline/hamsteradoption/HamsterDetailActivity.kt
|
MaxNeverSleep/HamsterAdoption
|
38416348921b78c2f51933ddbc287f234fd0ac5c
|
|
|
|
|
app/src/main/java/com/starline/hamsteradoption/HamsterDetailActivity.kt
|
MaxNeverSleep/HamsterAdoption
|
38416348921b78c2f51933ddbc287f234fd0ac5c
|
|
|
|
|
app/src/main/java/com/starline/hamsteradoption/HamsterDetailActivity.kt
|
MaxNeverSleep/HamsterAdoption
|
38416348921b78c2f51933ddbc287f234fd0ac5c
|
|
|
|
|
package com.starline.hamsteradoption
import android.graphics.Paint
import android.os.Bundle
import android.util.Log
import androidx.activity.compose.setContent
import androidx.appcompat.app.AppCompatActivity
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.graphics.scaleMatrix
import com.starline.hamsteradoption.ui.theme.HamsterAdoptionTheme
val hamsterAae = arrayOf(
"3 months",
"4 months",
"1 year 4 months",
"2 years",
"3 months",
"5 months",
"7 months",
"1 1moneths",
"1 months",
"3 months",
"8 months",
"1 months",
)
class HamsterDetailActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val name = intent.getStringExtra("HAMSTER_NAME")
val desc = intent.getStringExtra("HAMSTER_DESC")
var detailImage1: Int = 0
var detailImage2: Int = 0
var age: String = "1 months"
when (name) {
"Sussy" -> {
detailImage1 = R.mipmap.hamster_preview_1
detailImage2 = R.mipmap.hamster_1_1
age = "1 months"
}
"Jack" -> {
detailImage1 = R.mipmap.hamster_preview_2
detailImage2 = R.mipmap.hamster_2_1
age = "3 months"
}
"David" -> {
detailImage1 = R.mipmap.hamster_preview_3
detailImage2 = R.mipmap.hamster_3_1
age = "6 months"
}
"Stephen" -> {
detailImage1 = R.mipmap.hamster_preview_4
detailImage2 = R.mipmap.hamster_4_1
age = "4 months"
}
"Kiro" -> {
detailImage1 = R.mipmap.hamster_preview_5
detailImage2 = R.mipmap.hamster_5_1
age = "2 months"
}
"Warden" -> {
detailImage1 = R.mipmap.hamster_preview_6
detailImage2 = R.mipmap.hamster_6_1
age = "4 months"
}
"Love" -> {
detailImage1 = R.mipmap.hamster_preview_7
detailImage2 = R.mipmap.hamster_7_1
age = "2 months"
}
"Cookie" -> {
detailImage1 = R.mipmap.hamster_preview_8
detailImage2 = R.mipmap.hamster_8_1
age = "5 months"
}
"Hamster007" -> {
detailImage1 = R.mipmap.hamster_preview_9
detailImage2 = R.mipmap.hamster_5_1
age = "4 months"
}
"SweetHamster" -> {
detailImage1 = R.mipmap.hamster_preview_10
detailImage2 = R.mipmap.hamster_4_1
age = "6 months"
}
"Lam" -> {
detailImage1 = R.mipmap.hamster_preview_11
detailImage2 = R.mipmap.hamster_1_1
age = "7 months"
}
"Pinkie" -> {
detailImage1 = R.mipmap.hamster_preview_12
detailImage2 = R.mipmap.hamster_6_1
age = "12 months"
}
}
setContent {
HamsterAdoptionTheme {
MyDetail(name, age, detailImage1, detailImage2, { back() })
}
}
}
private fun back() {
Log.i("test", "finish activity结束")
super.finish()
}
}
@Composable
fun MyDetail(
name: String?,
age: String?,
detailImage1: Int,
detailImage2: Int,
onClick: () -> Unit
) {
Surface(color = MaterialTheme.colors.background) {
Column {
TopAppBar(
navigationIcon = {
IconButton(onClick = { onClick }) {
Icon(Icons.Filled.ArrowBack, "back")
}
},
title = {
Text(
text = "$name's Detail",
fontWeight = FontWeight.Bold
)
}
)
Row {
Image(
painter = painterResource(id = detailImage1),
contentDescription = name,
Modifier
.width(180.dp)
.height(180.dp)
.padding(30.dp, 30.dp),
contentScale = ContentScale.FillBounds
)
Text(
text = "Name : $name\r\n\nAge : $age\r\n\nDistance : 4.5km",
Modifier.padding(top = 40.dp),
fontWeight = FontWeight.Bold,
fontSize = 18.sp
)
}
Text(
text = "$name ,she’s really light for a dwarf, do not mistake her weight for her looks as when she arrived, she looks a lil preggie ...Turns out after 4 weeks, she just has a food baby and big hips (yes #bodygoals) Therefore, pls give Wheelington a chance even if you’re looking for a round hammy, light hams can be chonky too!",
Modifier.padding(horizontal = 30.dp, vertical = 10.dp),
style = MaterialTheme.typography.body2
)
Image(
painter = painterResource(id = detailImage2),
contentDescription = name,
Modifier
.width(400.dp)
.height(280.dp)
.padding(30.dp, 30.dp),
contentScale = ContentScale.FillBounds
)
}
}
}
|
|
|
|
|
8e447720674c91b173384fcd9c06cc17164dc87b
|
|
|
|
lib/fastly_nsq/manager.rb
|
|
e05d3972ebcfb25f7a42eb0268d482e5142d4658
|
|
|
|
|
lib/fastly_nsq/manager.rb
|
|
e05d3972ebcfb25f7a42eb0268d482e5142d4658
|
|
|
|
|
lib/fastly_nsq/manager.rb
|
|
e05d3972ebcfb25f7a42eb0268d482e5142d4658
|
|
|
|
|
# frozen_string_literal: true
##
# Interface for tracking listeners and managing the processing pool.
class FastlyNsq::Manager
DEADLINE = 30
# @return [Boolean] Set true when all listeners are stopped
attr_reader :done
# @return [FastlyNsq::PriorityThreadPool]
attr_reader :pool
# @return [Logger]
attr_reader :logger
##
# Create a FastlyNsq::Manager
#
# @param logger [Logger]
# @param max_threads [Integer] Maxiumum number of threads to be used by {FastlyNsq::PriorityThreadPool}
# @param pool_options [Hash] Options forwarded to {FastlyNsq::PriorityThreadPool} constructor.
def initialize(logger: FastlyNsq.logger, max_threads: FastlyNsq.max_processing_pool_threads, **pool_options)
@done = false
@logger = logger
@pool = FastlyNsq::PriorityThreadPool.new(
{ fallback_policy: :caller_runs, max_threads: max_threads }.merge(pool_options),
)
end
##
# Hash of listeners. Keys are topics, values are {FastlyNsq::Listener} instances.
# @return [Hash]
def topic_listeners
@topic_listeners ||= {}
end
##
# Array of listening topic names
# @return [Array]
def topics
topic_listeners.keys
end
##
# Set of {FastlyNsq::Listener} objects
# @return [Set]
def listeners
topic_listeners.values.to_set
end
##
# Stop the manager.
# Terminates the listeners and stops all processing in the pool.
# @param deadline [Integer] Number of seconds to wait for pool to stop processing
def terminate(deadline = DEADLINE)
return if done
stop_listeners
return if pool.shutdown?
stop_processing(deadline)
@done = true
end
##
# Manager state
# @return [Boolean]
def stopped?
done
end
##
# Add a {FastlyNsq::Listener} to the @topic_listeners
# @param listener [FastlyNsq::Listener}
def add_listener(listener)
logger.info { "topic #{listener.topic}, channel #{listener.channel}: listening" }
if topic_listeners[listener.topic]
logger.warn { "topic #{listener.topic}: duplicate listener" }
end
topic_listeners[listener.topic] = listener
end
##
# Transer listeners to a new manager and stop processing from the existing pool.
# @param new_manager [FastlyNsq::Manager] new manager to which listeners will be added
# @param deadline [Integer] Number of seconds to wait for exsiting pool to stop processing
def transfer(new_manager, deadline: DEADLINE)
new_manager.topic_listeners.merge!(topic_listeners)
stop_processing(deadline)
topic_listeners.clear
@done = true
end
##
# Terminate all listeners
def stop_listeners
logger.info { 'Stopping listeners' }
listeners.each(&:terminate)
topic_listeners.clear
end
protected
##
# Shutdown the pool
# @param deadline [Integer] Number of seconds to wait for pool to stop processing
def stop_processing(deadline)
logger.info { 'Stopping processors' }
pool.shutdown
logger.info { 'Waiting for processors to finish...' }
return if pool.wait_for_termination(deadline)
logger.info { 'Killing processors...' }
pool.kill
end
end
|
|
|
|
|
402fab453bb9e2ac59ef1604d2cf41a8d383046e
|
|
|
|
|
|
95b5d4a9d20df124040ff9335ad09409ca9ff607
|
|
|
|
|
|
|
95b5d4a9d20df124040ff9335ad09409ca9ff607
|
|
|
|
|
|
|
95b5d4a9d20df124040ff9335ad09409ca9ff607
|
|
|
|
|
from enum import Enum
class Move(Enum):
LEFT = -1
STRAIGHT = 0
RIGHT = 1
class Direction(Enum):
NORTH = 0
EAST = 1
SOUTH = 2
WEST = 3
def get_new_direction(self, move):
return Direction(self.value + move.value) % 4
def get_xy_manipulation(self):
m = {
Direction.NORTH: (0, -1),
Direction.EAST: (1, 0),
Direction.SOUTH: (0, 1),
Direction.WEST: (-1, 0)
}
return m[self]
def get_xy_moves(self):
m = {
Direction.NORTH: [Direction.NORTH.get_xy_manipulation(), Direction.EAST.get_xy_manipulation(),
Direction.WEST.get_xy_manipulation()],
Direction.EAST: [Direction.NORTH.get_xy_manipulation(), Direction.EAST.get_xy_manipulation(),
Direction.SOUTH.get_xy_manipulation()],
Direction.SOUTH: [Direction.SOUTH.get_xy_manipulation(), Direction.EAST.get_xy_manipulation(),
Direction.WEST.get_xy_manipulation()],
Direction.WEST: [Direction.NORTH.get_xy_manipulation(), Direction.WEST.get_xy_manipulation(),
Direction.SOUTH.get_xy_manipulation()],
}
return m[self]
|
|
|
|
|
dda83b2c35d62055796e4e123db761f5ab14e3a9
|
|
|
|
vendor/github.com/joomcode/redispipe/redis/request_writer.go
|
anuragprafulla/components-contrib
|
91be9ad2a0767526049e0c95225b5afb3791e353
|
|
|
|
|
vendor/github.com/joomcode/redispipe/redis/request_writer.go
|
anuragprafulla/components-contrib
|
91be9ad2a0767526049e0c95225b5afb3791e353
|
|
|
|
|
vendor/github.com/joomcode/redispipe/redis/request_writer.go
|
anuragprafulla/components-contrib
|
91be9ad2a0767526049e0c95225b5afb3791e353
|
|
|
|
|
package redis
import (
"strconv"
"github.com/joomcode/errorx"
)
// AppendRequest appends request to byte slice as RESP request (ie as array of strings).
//
// It could fail if some request value is not nil, integer, float, string or byte slice.
// In case of error it still returns modified buffer, but truncated to original size, it could be used save reallocation.
//
// Note: command could contain single space. In that case, it will be split and last part will be prepended to arguments.
func AppendRequest(buf []byte, req Request) ([]byte, error) {
oldSize := len(buf)
space := -1
for i, c := range []byte(req.Cmd) {
if c == ' ' {
space = i
break
}
}
if space == -1 {
buf = appendHead(buf, '*', len(req.Args)+1)
buf = appendHead(buf, '$', len(req.Cmd))
buf = append(buf, req.Cmd...)
buf = append(buf, '\r', '\n')
} else {
buf = appendHead(buf, '*', len(req.Args)+2)
buf = appendHead(buf, '$', space)
buf = append(buf, req.Cmd[:space]...)
buf = append(buf, '\r', '\n')
buf = appendHead(buf, '$', len(req.Cmd)-space-1)
buf = append(buf, req.Cmd[space+1:]...)
buf = append(buf, '\r', '\n')
}
for i, val := range req.Args {
switch v := val.(type) {
case string:
buf = appendHead(buf, '$', len(v))
buf = append(buf, v...)
case []byte:
buf = appendHead(buf, '$', len(v))
buf = append(buf, v...)
case int:
buf = appendBulkInt(buf, int64(v))
case uint:
buf = appendBulkUint(buf, uint64(v))
case int64:
buf = appendBulkInt(buf, int64(v))
case uint64:
buf = appendBulkUint(buf, uint64(v))
case int32:
buf = appendBulkInt(buf, int64(v))
case uint32:
buf = appendBulkUint(buf, uint64(v))
case int8:
buf = appendBulkInt(buf, int64(v))
case uint8:
buf = appendBulkUint(buf, uint64(v))
case int16:
buf = appendBulkInt(buf, int64(v))
case uint16:
buf = appendBulkUint(buf, uint64(v))
case bool:
if v {
buf = append(buf, "$1\r\n1"...)
} else {
buf = append(buf, "$1\r\n0"...)
}
case float32:
str := strconv.FormatFloat(float64(v), 'f', -1, 32)
buf = appendHead(buf, '$', len(str))
buf = append(buf, str...)
case float64:
str := strconv.FormatFloat(v, 'f', -1, 64)
buf = appendHead(buf, '$', len(str))
buf = append(buf, str...)
case nil:
buf = append(buf, "$0\r\n"...)
default:
return buf[:oldSize], ErrArgumentType.NewWithNoMessage().
WithProperty(EKVal, val).
WithProperty(EKArgPos, i).
WithProperty(EKRequest, req)
}
buf = append(buf, '\r', '\n')
}
return buf, nil
}
func appendInt(b []byte, i int64) []byte {
var u uint64
if i >= 0 && i <= 9 {
b = append(b, byte(i)+'0')
return b
}
if i > 0 {
u = uint64(i)
} else {
b = append(b, '-')
u = uint64(-i)
}
return appendUint(b, u)
}
func appendUint(b []byte, u uint64) []byte {
if u <= 9 {
b = append(b, byte(u)+'0')
return b
}
digits := [20]byte{}
p := 20
for u > 0 {
n := u / 10
p--
digits[p] = byte(u-n*10) + '0'
u = n
}
return append(b, digits[p:]...)
}
func appendHead(b []byte, t byte, i int) []byte {
if i < 0 {
panic("negative length header")
}
b = append(b, t)
b = appendUint(b, uint64(i))
return append(b, '\r', '\n')
}
func appendBulkInt(b []byte, i int64) []byte {
if i >= -99999999 && i <= 999999999 {
b = append(b, '$', '0', '\r', '\n')
} else {
b = append(b, '$', '0', '0', '\r', '\n')
}
l := len(b)
b = appendInt(b, i)
li := byte(len(b) - l)
if li < 10 {
b[l-3] = li + '0'
} else {
d := li / 10
b[l-4] = d + '0'
b[l-3] = li - (d * 10) + '0'
}
return b
}
func appendBulkUint(b []byte, i uint64) []byte {
if i <= 999999999 {
b = append(b, '$', '0', '\r', '\n')
} else {
b = append(b, '$', '0', '0', '\r', '\n')
}
l := len(b)
b = appendUint(b, i)
li := byte(len(b) - l)
if li < 10 {
b[l-3] = li + '0'
} else {
d := li / 10
b[l-4] = d + '0'
b[l-3] = li - (d * 10) + '0'
}
return b
}
// ArgToString returns string representataion of an argument.
// Used in cluster to determine cluster slot.
// Have to be in sync with AppendRequest
func ArgToString(arg interface{}) (string, bool) {
var bufarr [20]byte
var buf []byte
switch v := arg.(type) {
case string:
return v, true
case []byte:
return string(v), true
case int:
buf = appendInt(bufarr[:0], int64(v))
case uint:
buf = appendUint(bufarr[:0], uint64(v))
case int64:
buf = appendInt(bufarr[:0], int64(v))
case uint64:
buf = appendUint(bufarr[:0], uint64(v))
case int32:
buf = appendInt(bufarr[:0], int64(v))
case uint32:
buf = appendUint(bufarr[:0], uint64(v))
case int8:
buf = appendInt(bufarr[:0], int64(v))
case uint8:
buf = appendUint(bufarr[:0], uint64(v))
case int16:
buf = appendInt(bufarr[:0], int64(v))
case uint16:
buf = appendUint(bufarr[:0], uint64(v))
case bool:
if v {
return "1", true
}
return "0", true
case float32:
return strconv.FormatFloat(float64(v), 'f', -1, 32), true
case float64:
return strconv.FormatFloat(v, 'f', -1, 64), true
case nil:
return "", true
default:
return "", false
}
return string(buf), true
}
// CheckRequest checks requests command and arguments to be compatible with connector.
func CheckRequest(req Request, singleThreaded bool) error {
if err := ForbiddenCommand(req.Cmd, singleThreaded); err != nil {
return err.(*errorx.Error).WithProperty(EKRequest, req)
}
for i, arg := range req.Args {
switch val := arg.(type) {
case string, []byte, int, uint, int64, uint64, int32, uint32, int8, uint8, int16, uint16, bool, float32, float64, nil:
// ok
default:
return ErrArgumentType.NewWithNoMessage().
WithProperty(EKVal, val).
WithProperty(EKArgPos, i).
WithProperty(EKRequest, req)
}
}
return nil
}
|
|
|
|
|
402ca108a9c3f098029d64faeab25fe9ff44caf8
|
|
|
|
Mesh/System/Entity/Function/Powered.py
|
|
115e7391d19ea09db3c627d8b8ed90b3e3bef9b5
|
|
|
|
|
Mesh/System/Entity/Function/Powered.py
|
|
115e7391d19ea09db3c627d8b8ed90b3e3bef9b5
|
|
|
|
|
Mesh/System/Entity/Function/Powered.py
|
|
115e7391d19ea09db3c627d8b8ed90b3e3bef9b5
|
|
|
|
|
from enum import Enum
from Mesh.System.Entity.Channel.PowerWire import PowerWire
from Mesh.System.Entity.Function import BaseFunction, Function
from Mesh.System.Entity.Function.Tasked import TaskName, SystemTask
from Mesh.util.TypeList import TypeList
class PowerType(Enum):
ELECTRIC = 101
class Power:
def __init__(self, power_type):
self.power_type = power_type
class ElectricPower(Power):
def __init__(self, voltage):
super().__init__(PowerType.ELECTRIC)
self.voltage = voltage
def __eq__(self, other):
return self.power_type == other.power_type and self.voltage == other.voltage
def __str__(self):
return '%s(voltage=%s)' % (type(self).__name__, self.voltage)
class PowerInput:
identifier = 'PowerInput'
def __init__(self, parent, power=ElectricPower(voltage=0)):
self.parent = parent
self.power = power
self.power_wires = TypeList(PowerWire)
def set_power(self, power=ElectricPower(voltage=0)):
self.power = power
if self.parent.has_function(Function.TASKED):
self.parent.send_task(SystemTask(name=TaskName.SET_POWER, value={'power': power}))
else:
if self.power in self.parent.get_function(Function.POWERED).input_power_ratings:
self.parent.active = True
else:
self.parent.active = False
def get_power(self):
if len(self.power_wires) > 0:
return self.power_wires[0].get_power()
else:
return self.power
class PowerOutput:
identifier = 'PowerOutput'
def __init__(self, parent, power=ElectricPower(voltage=0)):
self.parent = parent
self.power = power
self.power_wires = TypeList(PowerWire)
def get_power(self):
return self.power
def set_power(self, power=ElectricPower(voltage=0)):
self.power = power
for wire in self.power_wires:
wire.set_power(self.power)
class Powered(BaseFunction):
tasks = [
TaskName.SET_POWER,
]
def __init__(self, entity):
super().__init__(entity)
self.power_inputs = TypeList(PowerInput)
self.power_outputs = TypeList(PowerOutput)
self.input_power_ratings = []
self.output_power_ratings = []
def eval(self):
pass
def init(self):
pass
def terminate(self):
pass
def get_power_input(self, index=0):
if index < len(self.power_inputs):
return self.power_inputs[index]
else:
raise IndexError
def get_power_output(self, index=0):
if index < len(self.power_outputs):
return self.power_outputs[index]
else:
raise IndexError
|
|
|
|
|
b0c17de3777c79065b9d41b281b353d09c785a63
|
|
|
|
network/src/main/kotlin/rs/dusk/network/rs/codec/game/encode/message/ContainerItemsMessage.kt
|
|
4af70ecb731d9ce292d086c81c21eda66bfaa040
|
|
|
|
|
network/src/main/kotlin/rs/dusk/network/rs/codec/game/encode/message/ContainerItemsMessage.kt
|
|
4af70ecb731d9ce292d086c81c21eda66bfaa040
|
|
|
|
|
network/src/main/kotlin/rs/dusk/network/rs/codec/game/encode/message/ContainerItemsMessage.kt
|
|
4af70ecb731d9ce292d086c81c21eda66bfaa040
|
|
|
|
|
package rs.dusk.network.rs.codec.game.encode.message
import rs.dusk.core.network.model.message.Message
/**
* Sends a list of items to display on a interface item group component
* @param key The id of the container
* @param items List of the item ids to display
* @param amounts List of the item amounts to display
* @param secondary Optional to send to the primary or secondary container
*/
data class ContainerItemsMessage(val key: Int, val items: IntArray, val amounts: IntArray, val secondary: Boolean) : Message {
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as ContainerItemsMessage
if (key != other.key) return false
if (!items.contentEquals(other.items)) return false
if (!amounts.contentEquals(other.amounts)) return false
if (secondary != other.secondary) return false
return true
}
override fun hashCode(): Int {
var result = key
result = 31 * result + items.contentHashCode()
result = 31 * result + amounts.contentHashCode()
result = 31 * result + secondary.hashCode()
return result
}
}
|
|
|
|
|
1bef23af1d1e1885b3fbe2f77c7b1a3aa023161b
|
|
|
|
tests/test_subscription.py
|
avito-tech/alert-autoconf
|
73d9270c6f9f0655cfc68ae3dac4e7406acf10ae
|
|
|
|
|
tests/test_subscription.py
|
avito-tech/alert-autoconf
|
73d9270c6f9f0655cfc68ae3dac4e7406acf10ae
|
|
|
|
|
tests/test_subscription.py
|
avito-tech/alert-autoconf
|
73d9270c6f9f0655cfc68ae3dac4e7406acf10ae
|
|
|
|
|
from unittest import TestCase
from alert_autoconf.moira import MoiraAlert
def _make_sub(**kwargs):
sub = {
'tags': [],
'contacts': [],
'escalations': [],
'sched': {'startOffset': 0, 'endOffset': 1439, 'tzOffset': 0, 'days': []},
}
sub.update(**kwargs)
return sub
def _make_esc(offset=10, contacts=None):
return {'contacts': contacts or [], 'offset_in_minutes': offset}
class SubscriptionCmpTest(TestCase):
def test_two_empty(self):
s1 = _make_sub()
s2 = _make_sub()
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertTrue(r)
def test_tags_changed(self):
s1 = _make_sub(tags=['t1'])
s2 = _make_sub()
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertFalse(r)
def test_tags_equal(self):
s1 = _make_sub(tags=['t1', 't2'])
s2 = _make_sub(tags=['t1', 't2'])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertTrue(r)
def test_contacts_equal(self):
s1 = _make_sub(contacts=['c1', 'c2'])
s2 = _make_sub(contacts=['c1', 'c2'])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertTrue(r)
def test_tags_and_contacts_equal(self):
s1 = _make_sub(contacts=['c1', 'c2'], tags=['t1'])
s2 = _make_sub(contacts=['c1', 'c2'], tags=['t1'])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertTrue(r)
def test_tags_and_contacts_not_equal(self):
s1 = _make_sub(contacts=['z1', 'c2'], tags=['t1'])
s2 = _make_sub(contacts=['c1', 'c2'], tags=['t1'])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertFalse(r)
def test_escalations_empty(self):
s1 = _make_sub(escalations=[_make_esc()])
s2 = _make_sub(escalations=[_make_esc()])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertTrue(r)
def test_escalations_diff_offsets(self):
s1 = _make_sub(escalations=[_make_esc(20)])
s2 = _make_sub(escalations=[_make_esc()])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertFalse(r)
def test_escalations_order(self):
s1 = _make_sub(escalations=[_make_esc(20), _make_esc(10)])
s2 = _make_sub(escalations=[_make_esc(10), _make_esc(20)])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertTrue(r)
def test_escalations_contacts_order(self):
s1 = _make_sub(escalations=[_make_esc(contacts=['1', '2'])])
s2 = _make_sub(escalations=[_make_esc(contacts=['2', '1'])])
r = MoiraAlert._subscription_not_changed(s1, s2)
self.assertTrue(r)
|
|
|
|
|
3d238d6a6e35dd9449ab92eabfd502e8e7e9c381
|
|
|
|
|
|
736a1bb8b5a76894138a8bd3b0f37a85d10871ae
|
|
|
|
|
|
|
736a1bb8b5a76894138a8bd3b0f37a85d10871ae
|
|
|
|
|
|
|
736a1bb8b5a76894138a8bd3b0f37a85d10871ae
|
|
|
|
|
package config
import (
"errors"
"fmt"
"github.com/spf13/viper"
"sync"
)
type JiraConfig struct {
Server string `mapstructure:"server"`
User string `mapstructure:"user"`
Password string `mapstructure:"password"`
}
type TodoistConfig struct {
Token string `mapstructure:"token"`
}
type Config struct {
Jira JiraConfig `mapstructure:"jira"`
Todoist TodoistConfig `mapstructure:"todoist"`
}
var instance Config
var once sync.Once
var initialised = false
func InitConfig(cfgFile string) (*Config, error) {
var onceErr error = nil
once.Do(func() {
viper.SetConfigFile(cfgFile)
viper.SetConfigType("toml")
if err := viper.ReadInConfig(); err != nil {
onceErr = errors.New(fmt.Sprintf("couldn't load config from %s: %s\n", cfgFile, err))
}
if err := viper.Unmarshal(&instance); err != nil {
onceErr = errors.New(fmt.Sprintf("couldn't read config: %s\n", err))
}
initialised = true
})
if onceErr == nil {
return &instance, nil
} else {
return nil, onceErr
}
}
func GetConfig() (*Config, error) {
if !initialised {
return nil, errors.New("config is not initialised yet, please call InitConfig(cfgFile)")
}
return &instance, nil
}
|
|
|
|
|
7f71cd62fefa40eebb9ea107e698b6ca746b7814
|
|
|
|
internal/logger/logger.go
|
|
7f5a8a9ca8801684a2008213435ecff4f142506c
|
|
|
|
|
internal/logger/logger.go
|
|
7f5a8a9ca8801684a2008213435ecff4f142506c
|
|
|
|
|
internal/logger/logger.go
|
|
7f5a8a9ca8801684a2008213435ecff4f142506c
|
|
|
|
|
package logger
import (
"fmt"
"os"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
var logger serviceLogger
var origLogger serviceLogger
func init() {
initLogger()
}
// LogSync sync logger output
func LogSync() {
// ignore logger Sync error
logger.Sync()
}
// SetLogger sets caller provided zap logger
//
// reset to service's default logger by passing in nil pointer
func SetLogger(l *zap.Logger) {
if l != nil {
logger.Logger = l
logger.provided = true
return
}
logger = origLogger
}
// SetLogLevel sets the service log level
//
// noop if caller provides it's own zap logger
func SetLogLevel(level zapcore.Level) {
if logger.provided {
return
}
logger.config.Level.SetLevel(level)
}
func initLogger() {
// default log level set to 'info'
atom := zap.NewAtomicLevelAt(zap.InfoLevel)
config := zap.Config{
Level: atom,
Development: false,
Sampling: &zap.SamplingConfig{
Initial: 100,
Thereafter: 100,
},
Encoding: "json", // console, json, toml
EncoderConfig: zap.NewProductionEncoderConfig(),
OutputPaths: []string{"stderr"},
ErrorOutputPaths: []string{"stderr"},
}
mylogger, err := config.Build()
if err != nil {
fmt.Printf("Initialize zap logger error: %v\n", err)
os.Exit(1)
}
logger = serviceLogger{mylogger, &config, false}
origLogger = logger
}
// GetLog gets the current logger
func GetLog() serviceLogger {
return logger
}
|
|
|
|
|
857b8c2dbc0be5ef308797b18469cd500d2836fa
|
|
|
|
|
|
c5c179e83692f371c722178d4af62398d0eabe1c
|
|
|
|
|
|
|
c5c179e83692f371c722178d4af62398d0eabe1c
|
|
|
|
|
|
|
c5c179e83692f371c722178d4af62398d0eabe1c
|
|
|
|
|
module.exports = ({log}) => ({
data(done) {
log.step('data:db')
global.DB = require('./db')(() => {
let seeder = require('./db.seed')(DB, OPTS)
seeder.testToSeed(y => y ? seeder.restoreBSONData(done) : done())
})
let ISODate = global.ISODate = str => moment(str).toDate()
let ID = global.ID = global.ObjectId = (DB||{}).ObjectId
log.step('data:fixture')
global.FIXTURE = require('./data.fixture')
if (!DB) done()
return { ISODate, ID }
},
runner() {
let Mocha = require('mocha')
log.step('tests:init')
return new Mocha(OPTS.config.mocha)
.addFile(join(__dirname,'runner'))
.run(status => {
log.info('DONE', `${status==0?'No':'With'} errors\n`).flush()
process.exit(status)
})
},
app(done) {
let start = new Date()
log.step('app:init')
global.APP = OPTS.App(function(e) {
log.info('APP', `${e?'fail':'ready'} (${new Date()-start}ms)`).flush()
log.step('tests:run')
done(e)
})
},
/*
If unhandledPromiseRejection f => Error, p => Profile
If failed test / assertion f => mocha.ctx, p => Error
*/
fail(f, p) {
// console.log('in fail....', f, p)
if (f.stack)
log.error(f)
else if ((p instanceof Error))
log.error(p)
log.info('FAIL', `${log.step()} `.white + `${log.runner.scope.join(' > ')}`.spec)
process.exit(1) // Exiting stops default mocha exit output
}
})
|
|
|
|
|
f076aaf49a3d8fba6fb5ba17c6020bb113d2de01
|
|
|
|
|
youhengzhou/json-crud-engine
|
8ee614af6dddbe1236a78a7debf71048f476a3ff
|
|
|
|
|
|
youhengzhou/json-crud-engine
|
8ee614af6dddbe1236a78a7debf71048f476a3ff
|
|
|
|
|
|
youhengzhou/json-crud-engine
|
8ee614af6dddbe1236a78a7debf71048f476a3ff
|
|
|
|
|
# JSON engine 21 9 16
# database
# eng.json
# engine
# eng.py
import os
import json
path = os.getcwd() + '\\json_engine_database\\'
path_string = ''
def set_path(string):
global path
path = os.getcwd() + string
def dictionary_kv(dictionary, key, value):
dictionary[key] = value
return dictionary
def set_path_string(args,create_flag):
global path_string
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string)==False:
if create_flag == True:
os.makedirs(path + path_string)
else:
return False
return path_string
def create(dictionary, *args):
path_string = set_path_string(args,True)
with open(path + path_string + 'eng.json', 'w') as outfile:
json.dump(dictionary, outfile, indent=4)
def retrieve(*args):
path_string = set_path_string(args,False)
if path_string == False:
return False
with open(path + path_string + 'eng.json', 'r') as f:
return(json.load(f))
def retrieve_k(key, *args):
path_string = set_path_string(args,False)
if path_string == False:
return False
with open(path + path_string + 'eng.json', 'r') as f:
if key in json.load(f):
with open(path + path_string + 'eng.json', 'r') as f:
return(json.load(f)[key])
else:
return False
def update(dictionary, *args):
path_string = set_path_string(args,False)
if path_string == False:
return False
with open(path + path_string + 'eng.json', 'w') as outfile:
json.dump(dictionary, outfile, indent=4)
return True
def update_kv(key, value, *args):
path_string = set_path_string(args,False)
if path_string == False:
return False
with open(path + path_string + 'eng.json', 'w') as outfile:
json.dump({key: value}, outfile, indent=4)
return True
def patch(dictionary, *args):
path_string = set_path_string(args,False)
if path_string == False:
return False
with open(path + path_string + 'eng.json', 'r') as f:
data=(json.load(f))
data.update(dictionary)
with open(path + path_string + 'eng.json', 'w') as outfile:
json.dump(data, outfile, indent=4)
return True
def patch_kv(key, value, *args):
path_string = set_path_string(args,False)
if path_string == False:
return False
with open(path + path_string + 'eng.json', 'r') as f:
data=(json.load(f))
data.update({key: value})
with open(path + path_string + 'eng.json', 'w') as outfile:
json.dump(data, outfile, indent=4)
return True
def delete(*args):
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string + 'eng.json'):
os.remove(path + path_string + 'eng.json')
os.rmdir(path + path_string)
return True
else:
return False
def delete_k(key, *args):
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string + 'eng.json'):
with open(path + path_string + 'eng.json', 'r') as f:
if key in json.load(f):
data = json.load(f)
data.pop(key)
with open(path + path_string + 'eng.json', 'w') as outfile:
json.dump(data, outfile, indent=4)
return True
else:
return False
else:
return False
def display(*args):
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string + 'eng.json'):
with open(path + path_string + 'eng.json', 'r') as f:
print(json.load(f))
return True
else:
print('The selected file does not exist')
return False
def display_key(key, *args):
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string + 'eng.json'):
with open(path + path_string + 'eng.json', 'r') as f:
if key in json.load(f):
print(key + ' ' + str(json.load(f)[key]))
return True
else:
print('The selected file does not exist')
return False
def display_nkv(key, *args):
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string + 'eng.json'):
with open(path + path_string + 'eng.json', 'r') as f:
if key in json.load(f):
data = json.load(f)
data.pop(key,'key not found')
print(data)
return True
else:
print('The selected file does not exist')
return False
def display_ind(*args):
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string + 'eng.json'):
with open(path + path_string + 'eng.json', 'r') as f:
print(json.dumps(json.load(f), indent=4))
else:
print('The selected file does not exist')
def display_ind_nkv(key, *args):
if (args):
path_string = str(args[0]) + '\\'
if os.path.exists(path + path_string + 'eng.json'):
with open(path + path_string + 'eng.json', 'r') as f:
data = json.load(f)
data.pop(key,'key not found')
print(json.dumps(data, indent=4))
else:
print('The selected file does not exist')
|
|
|
|
|
19d428aad36966348419dd413eabc7e98a9aa51d
|
|
|
|
Plugins/UnrealLua/LuaSource/luahotupdate.lua
|
|
61a7f3fd2e967ffd970c9b2ac72f12aa2af34bd8
|
|
|
|
|
Plugins/UnrealLua/LuaSource/luahotupdate.lua
|
|
61a7f3fd2e967ffd970c9b2ac72f12aa2af34bd8
|
|
|
|
|
Plugins/UnrealLua/LuaSource/luahotupdate.lua
|
|
61a7f3fd2e967ffd970c9b2ac72f12aa2af34bd8
|
|
|
|
|
if _VERSION == "Lua 5.3" then
function getfenv(f)
if type(f) == "function" then
local name, value = debug.getupvalue(f, 1)
if name == "_ENV" then
return value
else
return _ENV
end
end
end
function setfenv(f, Env)
if type(f) == "function" then
local name, value = debug.getupvalue(f, 1)
if name == "_ENV" then
debug.setupvalue(f, 1, Env)
end
end
end
debug = debug or {}
debug.setfenv = setfenv
function loadstring( ... )
return load(...)
end
end
local HU = {}
function HU.FailNotify(...)
if HU.NotifyFunc then HU.NotifyFunc(...) end
end
function HU.DebugNofity(...)
if HU.DebugNofityFunc then HU.DebugNofityFunc(...) end
end
local function GetWorkingDir()
if HU.WorkingDir == nil then
local p = io.popen("echo %cd%")
if p then
HU.WorkingDir = p:read("*l").."\\"
p:close()
end
end
return HU.WorkingDir
end
local function Normalize(path)
path = path:gsub("/","\\")
if path:find(":") == nil then
path = GetWorkingDir()..path
end
local pathLen = #path
if path:sub(pathLen, pathLen) == "\\" then
path = path:sub(1, pathLen - 1)
end
local parts = { }
for w in path:gmatch("[^\\]+") do
if w == ".." and #parts ~=0 then table.remove(parts)
elseif w ~= "." then table.insert(parts, w)
end
end
return table.concat(parts, "\\")
end
function HU.InitFileMap(RootPath)
local TheMap = {}
for _, rootpath in pairs(RootPath) do
rootpath = Normalize(rootpath)
local file = io.popen("dir /S/B /A:A \""..rootpath.."\"")
io.input(file)
for line in io.lines() do
local FileName = string.match(line,".*\\(.*)%.lua")
if FileName ~= nil then
if TheMap[FileName] == nil then
TheMap[FileName] = {}
end
local luapath = string.sub(line, #rootpath+2, #line-4)
luapath = string.gsub(luapath, "\\", ".")
HU.LuaPathToSysPath[luapath] = SysPath
table.insert(TheMap[FileName], {SysPath = line, LuaPath = luapath})
end
end
file:close()
end
return TheMap
end
function HU.InitFakeTable()
local meta = {}
HU.Meta = meta
local function FakeT() return setmetatable({}, meta) end
local function EmptyFunc() end
local function pairs() return EmptyFunc end
local function setmetatable(t, metaT)
HU.MetaMap[t] = metaT
return t
end
local function getmetatable(t, metaT)
return setmetatable({}, t)
end
local function require(LuaPath)
if not HU.RequireMap[LuaPath] then
local FakeTable = FakeT()
HU.RequireMap[LuaPath] = FakeTable
end
return HU.RequireMap[LuaPath]
end
function meta.__index(t, k)
if k == "setmetatable" then
return setmetatable
elseif k == "pairs" or k == "ipairs" then
return pairs
elseif k == "next" then
return EmptyFunc
elseif k == "require" then
return require
elseif HU.CallOriginFunctions and HU.CallOriginFunctions[k] then
return _G[k]
else
local FakeTable = FakeT()
rawset(t, k, FakeTable)
return FakeTable
end
end
function meta.__newindex(t, k, v) rawset(t, k, v) end
function meta.__call() return FakeT(), FakeT(), FakeT() end
function meta.__add() return meta.__call() end
function meta.__sub() return meta.__call() end
function meta.__mul() return meta.__call() end
function meta.__div() return meta.__call() end
function meta.__mod() return meta.__call() end
function meta.__pow() return meta.__call() end
function meta.__unm() return meta.__call() end
function meta.__concat() return meta.__call() end
function meta.__eq() return meta.__call() end
function meta.__lt() return meta.__call() end
function meta.__le() return meta.__call() end
function meta.__len() return meta.__call() end
return FakeT
end
function HU.InitProtection()
HU.Protection = {}
HU.Protection[setmetatable] = true
HU.Protection[pairs] = true
HU.Protection[ipairs] = true
HU.Protection[next] = true
HU.Protection[require] = true
HU.Protection[HU] = true
HU.Protection[HU.Meta] = true
HU.Protection[math] = true
HU.Protection[string] = true
HU.Protection[table] = true
end
function HU.AddFileFromHUList()
package.loaded[HU.UpdateListFile] = nil
local FileList = require (HU.UpdateListFile)
HU.ALL = false
HU.HUMap = {}
for _, file in pairs(FileList) do
if file == "_ALL_" then
HU.ALL = true
for k, v in pairs(HU.FileMap) do
for _, path in pairs(v) do
HU.HUMap[path.LuaPath] = path.SysPath
end
end
return
end
if not HU.FileMap[file] then
if HU.TryReloadFileCount[file] == nil or HU.TryReloadFileCount[file] == 0 then
HU.FileMap = HU.InitFileMap(HU.RootPath)
if not HU.FileMap[file] then
HU.FailNotify("HotUpdate can't not find "..file)
HU.TryReloadFileCount[file] = 3
end
else
HU.TryReloadFileCount[file] = HU.TryReloadFileCount[file] - 1
end
end
if HU.FileMap[file] then
for _, path in pairs(HU.FileMap[file]) do
HU.HUMap[path.LuaPath] = path.SysPath
end
end
end
end
function HU.ErrorHandle(e)
HU.FailNotify("HotUpdate Error\n"..tostring(e))
HU.ErrorHappen = true
end
function HU.LoadStringFunc(SysPath)
io.input(SysPath)
local CodeStr = io.read("*all")
io.input():close()
return CodeStr
end
function HU.BuildNewCode(SysPath, LuaPath)
local NewCode = HU.LoadStringFunc(SysPath)
if HU.ALL and HU.OldCode[SysPath] == nil then
HU.OldCode[SysPath] = NewCode
return
end
if HU.OldCode[SysPath] == NewCode then
return false
end
HU.DebugNofity(SysPath)
local chunk = "--[["..LuaPath.."]] "
chunk = chunk..NewCode
local NewFunction = loadstring(chunk)
if not NewFunction then
HU.FailNotify(SysPath.." has syntax error.")
collectgarbage("collect")
return false
else
HU.FakeENV = HU.FakeT()
HU.MetaMap = {}
HU.RequireMap = {}
setfenv(NewFunction, HU.FakeENV)
local NewObject
HU.ErrorHappen = false
xpcall(function () NewObject = NewFunction() end, HU.ErrorHandle)
if not HU.ErrorHappen then
HU.OldCode[SysPath] = NewCode
return true, NewObject
else
collectgarbage("collect")
return false
end
end
end
function HU.Travel_G()
local visited = {}
visited[HU] = true
local function f(t)
if (type(t) ~= "function" and type(t) ~= "table") or visited[t] or HU.Protection[t] then return end
visited[t] = true
if type(t) == "function" then
for i = 1, math.huge do
local name, value = debug.getupvalue(t, i)
if not name then break end
if type(value) == "function" then
for _, funcs in ipairs(HU.ChangedFuncList) do
if value == funcs[1] then
debug.setupvalue(t, i, funcs[2])
end
end
end
f(value)
end
elseif type(t) == "table" then
f(debug.getmetatable(t))
local changeIndexs = {}
for k,v in pairs(t) do
f(k); f(v);
if type(v) == "function" then
for _, funcs in ipairs(HU.ChangedFuncList) do
if v == funcs[1] then t[k] = funcs[2] end
end
end
if type(k) == "function" then
for index, funcs in ipairs(HU.ChangedFuncList) do
if k == funcs[1] then changeIndexs[#changeIndexs+1] = index end
end
end
end
for _, index in ipairs(changeIndexs) do
local funcs = HU.ChangedFuncList[index]
t[funcs[2]] = t[funcs[1]]
t[funcs[1]] = nil
end
end
end
f(_G)
local registryTable = debug.getregistry()
f(registryTable)
for _, funcs in ipairs(HU.ChangedFuncList) do
if funcs[3] == "HUDebug" then funcs[4]:HUDebug() end
end
end
function HU.ReplaceOld(OldObject, NewObject, LuaPath, From, Deepth)
if type(OldObject) == type(NewObject) then
if type(NewObject) == "table" then
HU.UpdateAllFunction(OldObject, NewObject, LuaPath, From, "")
elseif type(NewObject) == "function" then
HU.UpdateOneFunction(OldObject, NewObject, LuaPath, nil, From, "")
end
end
end
function HU.HotUpdateCode(LuaPath, SysPath)
local OldObject = package.loaded[LuaPath]
if OldObject ~= nil then
HU.VisitedSig = {}
HU.ChangedFuncList = {}
local Success, NewObject = HU.BuildNewCode(SysPath, LuaPath)
if Success then
HU.ReplaceOld(OldObject, NewObject, LuaPath, "Main", "")
for LuaPath, NewObject in pairs(HU.RequireMap) do
local OldObject = package.loaded[LuaPath]
HU.ReplaceOld(OldObject, NewObject, LuaPath, "Main_require", "")
end
setmetatable(HU.FakeENV, nil)
HU.UpdateAllFunction(HU.ENV, HU.FakeENV, " ENV ", "Main", "")
if #HU.ChangedFuncList > 0 then
HU.Travel_G()
end
collectgarbage("collect")
end
elseif HU.OldCode[SysPath] == nil then
HU.OldCode[SysPath] = HU.LoadStringFunc(SysPath)
end
end
function HU.ResetENV(object, name, From, Deepth)
local visited = {}
local function f(object, name)
if not object or visited[object] then return end
visited[object] = true
if type(object) == "function" then
HU.DebugNofity(Deepth.."HU.ResetENV", name, " from:"..From)
xpcall(function () setfenv(object, HU.ENV) end, HU.FailNotify)
elseif type(object) == "table" then
HU.DebugNofity(Deepth.."HU.ResetENV", name, " from:"..From)
for k, v in pairs(object) do
f(k, tostring(k).."__key", " HU.ResetENV ", Deepth.." " )
f(v, tostring(k), " HU.ResetENV ", Deepth.." ")
end
end
end
f(object, name)
end
function HU.UpdateUpvalue(OldFunction, NewFunction, Name, From, Deepth)
HU.DebugNofity(Deepth.."HU.UpdateUpvalue", Name, " from:"..From)
local OldUpvalueMap = {}
local OldExistName = {}
for i = 1, math.huge do
local name, value = debug.getupvalue(OldFunction, i)
if not name then break end
OldUpvalueMap[name] = value
OldExistName[name] = true
end
for i = 1, math.huge do
local name, value = debug.getupvalue(NewFunction, i)
if not name then break end
if OldExistName[name] then
local OldValue = OldUpvalueMap[name]
if type(OldValue) ~= type(value) then
debug.setupvalue(NewFunction, i, OldValue)
elseif type(OldValue) == "function" then
HU.UpdateOneFunction(OldValue, value, name, nil, "HU.UpdateUpvalue", Deepth.." ")
elseif type(OldValue) == "table" then
HU.UpdateAllFunction(OldValue, value, name, "HU.UpdateUpvalue", Deepth.." ")
debug.setupvalue(NewFunction, i, OldValue)
else
debug.setupvalue(NewFunction, i, OldValue)
end
else
HU.ResetENV(value, name, "HU.UpdateUpvalue", Deepth.." ")
end
end
end
function HU.UpdateOneFunction(OldObject, NewObject, FuncName, OldTable, From, Deepth)
if HU.Protection[OldObject] or HU.Protection[NewObject] then return end
if OldObject == NewObject then return end
local signature = tostring(OldObject)..tostring(NewObject)
if HU.VisitedSig[signature] then return end
HU.VisitedSig[signature] = true
HU.DebugNofity(Deepth.."HU.UpdateOneFunction "..FuncName.." from:"..From)
if pcall(debug.setfenv, NewObject, getfenv(OldObject)) then
HU.UpdateUpvalue(OldObject, NewObject, FuncName, "HU.UpdateOneFunction", Deepth.." ")
HU.ChangedFuncList[#HU.ChangedFuncList + 1] = {OldObject, NewObject, FuncName, OldTable}
end
end
function HU.UpdateAllFunction(OldTable, NewTable, Name, From, Deepth)
if HU.Protection[OldTable] or HU.Protection[NewTable] then return end
local IsSame = getmetatable(OldTable) == getmetatable(NewTable)
local IsSame = IsSame and OldTable == NewTable
if IsSame == true then return end
local signature = tostring(OldTable)..tostring(NewTable)
if HU.VisitedSig[signature] then return end
HU.VisitedSig[signature] = true
HU.DebugNofity(Deepth.."HU.UpdateAllFunction "..Name.." from:"..From)
for ElementName, Element in pairs(NewTable) do
local OldElement = OldTable[ElementName]
if type(Element) == type(OldElement) then
if type(Element) == "function" then
HU.UpdateOneFunction(OldElement, Element, ElementName, OldTable, "HU.UpdateAllFunction", Deepth.." ")
elseif type(Element) == "table" then
HU.UpdateAllFunction(OldElement, Element, ElementName, "HU.UpdateAllFunction", Deepth.." ")
end
elseif OldElement == nil and type(Element) == "function" then
if pcall(setfenv, Element, HU.ENV) then
OldTable[ElementName] = Element
end
end
end
local OldMeta = debug.getmetatable(OldTable)
local NewMeta = HU.MetaMap[NewTable]
if type(OldMeta) == "table" and type(NewMeta) == "table" then
HU.UpdateAllFunction(OldMeta, NewMeta, Name.."'s Meta", "HU.UpdateAllFunction", Deepth.." ")
end
end
function HU.SetFileLoader(InitFileMapFunc, LoadStringFunc)
HU.InitFileMap = InitFileMapFunc
HU.LoadStringFunc = LoadStringFunc
end
function HU.Init(UpdateListFile, RootPath, FailNotify, ENV, CallOriginFunctions)
HU.UpdateListFile = UpdateListFile
HU.HUMap = {}
HU.FileMap = {}
HU.NotifyFunc = FailNotify
HU.OldCode = {}
HU.ChangedFuncList = {}
HU.VisitedSig = {}
HU.FakeENV = nil
HU.ENV = ENV or _G
HU.LuaPathToSysPath = {}
HU.RootPath = RootPath
HU.FileMap = HU.InitFileMap(RootPath)
HU.FakeT = HU.InitFakeTable()
HU.CallOriginFunctions = CallOriginFunctions
HU.InitProtection()
HU.ALL = false
HU.TryReloadFileCount = {}
end
function HU.Update()
HU.AddFileFromHUList()
for LuaPath, SysPath in pairs(HU.HUMap) do
HU.HotUpdateCode(LuaPath, SysPath)
end
end
return HU
|
|
|
|
|
bc5bf135a68e1a20f8283e82b82ae3e27ca64d3a
|
|
|
|
source/tokeniser/tokenise/tokenise.asm
|
paulscottrobson/6502-basic
|
d4c360041bfa49427a506465e58bb0ef94beaa44
|
|
|
|
|
source/tokeniser/tokenise/tokenise.asm
|
paulscottrobson/6502-Basic
|
d4c360041bfa49427a506465e58bb0ef94beaa44
|
|
|
|
|
source/tokeniser/tokenise/tokenise.asm
|
paulscottrobson/6502-Basic
|
d4c360041bfa49427a506465e58bb0ef94beaa44
|
|
|
|
|
; ************************************************************************************************
; ************************************************************************************************
;
; Name: tokenise.asm
; Purpose: Tokenise a string
; Created: 8th March 2021
; Reviewed: 16th March 2021
; Author: Paul Robson ([email protected])
;
; ************************************************************************************************
; ************************************************************************************************
.section storage
tokenHeader: ; bytes (all zero) to create a fake 'program line'
.fill 3
tokenBuffer: ; token buffer.
.fill 256
tokenBufferIndex: ; count of characters in buffer.
.fill 1
.send storage
.section code
; ************************************************************************************************
;
; Tokenise string at (codePtr) into tokenising buffer
; A != 0 if tokenising successful.
;
; ************************************************************************************************
Tokenise: ;; <tokenise>
jsr TokeniseMakeASCIIZ ; convert to ASCIIZ string.
TokeniseASCIIZ: ;; <tokenisez>
jsr TokeniseFixCase ; remove controls and lower case outside quotes.
lda #0 ; reset the token buffer index
sta tokenBufferIndex
tay ; start pointer
lda #$80 ; empty token buffer ($80 ends it)
sta tokenBuffer
;
; Main tokenisation loop
;
_TokLoop:
lda (codePtr),y ; get next character
beq _TokExit ; if zero, then exit.
iny ; skip over spaces.
cmp #" "
beq _TokLoop
dey ; point back to character.
cmp #"&" ; Hexadecimal constant.
beq _TokHexConst
cmp #'"' ; Quoted String
beq _TokQString
cmp #"Z"+1 ; > 'Z' is punctuation
bcs _TokPunctuation
cmp #"A" ; A..Z identifier
bcs _TokIdentifier
cmp #"9"+1
bcs _TokPunctuation ; between 9 and A exclusive, punctuation
cmp #"0"
bcc _TokPunctuation ; < 0, punctuation.
lda #10 ; 0..9 constant in base 10.
bne _TokConst
;
; Handle hexadecimal constant.
;
_TokHexConst:
iny ; consume token.
lda #TKW_AMP ; Write ampersand token out
jsr TokenWrite
lda #16
;
; Handle constant in base A
;
_TokConst:
jsr TokeniseInteger
bcs _TokLoop
bcc _TokFail
;
; Quoted string
;
_TokQString:
jsr TokeniseString
bcs _TokLoop
bcc _TokFail
;
; Punctuation token.
;
_TokPunctuation:
jsr TokenisePunctuation
bcs _TokLoop
bcc _TokFail
;
; Identifier or text token
;
_TokIdentifier:
jsr TokeniseIdentifier
bcs _TokLoop
bcc _TokFail
_TokExit:
lda #1
rts
_TokFail:
lda #0
rts
; ************************************************************************************************
;
; Write A to tokenise buffer
;
; ************************************************************************************************
TokenWrite:
sta tempShort ; save XA
pha
.pshx
lda tempShort
ldx tokenBufferIndex ; geet index
sta tokenBuffer,x ; write byte to buffer
lda #TOK_EOL ; pre-emptively write EOL marker after
sta tokenBuffer+1,x
inc tokenBufferIndex ; bump index
.pulx
pla
rts
; ************************************************************************************************
;
; Make string at (codePtr) ASCIIZ
;
; ************************************************************************************************
TokeniseMakeASCIIZ:
ldy #0 ; get length of string.
lda (codePtr),y
tay
iny ; +1, the NULL goes here.
lda #0
sta (codePtr),y ; write the trailing NULL.
inc codePtr ; bump the pointer.
bne _TMKAExit
inc codePtr+1
_TMKAExit:
rts
; ************************************************************************************************
;
; Make upper case and remove controls for everything outside quotes.
;
; ************************************************************************************************
TokeniseFixCase:
ldy #0 ; position in buffer.
ldx #1 ; bit 0 of this is 'in quotes'
_TFCFlipQ:
txa
eor #1
tax
_TFCLoop:
lda (codePtr),y ; get character
beq _TFCExit ; if zero exit.
cmp #32 ; if control
bcc _TFCControl
iny ; preconsume
cmp #'"'
beq _TFCFlipQ
cmp #"a" ; check if L/C
bcc _TFCLoop
cmp #"z"+1
bcs _TFCLoop
;
cpx #0 ; in quotes, if so, leave alone.
bne _TFCLoop
dey
eor #"A"^"a" ; make U/C
_TFCWrite:
sta (codePtr),y
iny
jmp _TFCLoop
;
_TFCControl:
lda #" "
bne _TFCWrite
_TFCExit:
rts
.send code
|
|
|
|
|
40af8c8f3236438b38a2ec95b565b4efbf998b1b
|
|
|
|
|
|
aea56049025ed7e6e66427f8636286f8be1b6e03
|
|
|
|
|
|
|
aea56049025ed7e6e66427f8636286f8be1b6e03
|
|
|
|
|
|
|
aea56049025ed7e6e66427f8636286f8be1b6e03
|
|
|
|
|
import gzip
import pickle
import networkx as nx
import matplotlib.pyplot as plt
from smart_open import open
"""
Some util functions used to navigate into Airflow DAGs.
"""
def breadth_first_search_task_list(task_root, task_list=[], mode='upstream'):
sub_task_list = []
queue = [task_root]
while len(queue) > 0:
task = queue.pop(0)
sub_task_list.append(task)
next_tasks = None
if mode == 'upstream':
next_tasks = task.upstream_list
else:
next_tasks = task.downstream_list
for next_task in next_tasks:
if next_task not in queue and next_task not in task_list and next_task not in sub_task_list:
queue.append(next_task)
return sub_task_list
def breadth_first_search_shell_list(task_roots):
shell_task_list = [task_roots]
done_tasks = set()
queue = task_roots
while len(queue) > 0:
tasks = queue
next_tasks = []
for task in tasks:
for next_task in task.downstream_list:
if next_task not in done_tasks:
next_tasks.append(next_task)
done_tasks.add(next_task)
if len(next_tasks) > 0:
shell_task_list.append(next_tasks)
queue = next_tasks
return shell_task_list
def get_dag_roots(dag):
roots = []
for task in dag.tasks:
if len(task.upstream_list) == 0:
roots.append(task)
return roots
def execute_dag(dag, verbose=False, mode='downstream'):
task_list = []
roots = dag.roots
for root in roots:
sub_task_list = breadth_first_search_task_list(root, task_list, mode=mode)
task_list = sub_task_list + task_list
for task in task_list:
if verbose:
print(dag.dag_id + '-' + str(task))
if task.task_type == 'SubDagOperator':
execute_dag(task.subdag, verbose=verbose)
else:
task.execute(dag.get_template_env())
return task_list
def plot_dag(dag):
fig, ax = plt.subplots(figsize=(15, 10), dpi=150)
G = nx.DiGraph()
color_list = []
for task in dag.tasks:
if len(task.downstream_list) > 0:
for next_task in task.downstream_list:
G.add_edge(task, next_task)
for node in G.nodes():
if len(node.ui_color) == 7:
color_list.append(node.ui_color)
else:
last_code = node.ui_color[-1]
color_list.append(str(node.ui_color).ljust(7, last_code))
pos = nx.drawing.nx_agraph.graphviz_layout(G, prog='dot')
nx.draw_networkx_nodes(G, pos, node_shape='D', node_color=color_list)
nx.draw_networkx_edges(G, pos, edge_color='gray', alpha=0.8)
nx.draw_networkx_labels(G, pos, font_size=5)
ax.set_axis_off()
plt.title("DAG preview", fontsize=8)
plt.show()
"""
Some utils function used to persist objects.
"""
def pickle_compress(obj):
return gzip.zlib.compress(pickle.dumps(obj))
def decompress_unpickle(obj_zp):
return pickle.loads(gzip.zlib.decompress(obj_zp))
def write_object_file(file_path, obj):
obj_pz = pickle_compress(obj)
file_obj = open(file_path, 'wb')
file_obj.write(obj_pz)
file_obj.close()
def load_object_file(file_path):
file_obj = open(file_path, 'rb')
obj_pz = file_obj.read()
obj = decompress_unpickle(obj_pz)
return obj
"""
Some misc utils.
"""
def pandas_downcast_numeric(df_to_downcast, float_type_to_downcast=("float64", "float32"),
int_type_to_downcast=("int64", "int32")):
float_cols = [c for c in df_to_downcast.columns if df_to_downcast[c].dtype == float_type_to_downcast[0]]
int_cols = [c for c in df_to_downcast.columns if df_to_downcast[c].dtype == int_type_to_downcast[0]]
df_to_downcast[float_cols] = df_to_downcast[float_cols].apply(lambda x: x.astype(float_type_to_downcast[1]))
df_to_downcast[int_cols] = df_to_downcast[int_cols].apply(lambda x: x.astype(int_type_to_downcast[1]))
def format_dict_path_items(dictionary, replace_value):
for k, v in dictionary.items():
if isinstance(v, dict):
dictionary[k] = format_dict_path_items(v, replace_value)
else:
if isinstance(v, list):
formatted_list = []
for list_item in v:
if type(list_item) == str:
list_item = list_item.format(replace_value)
formatted_list.append(list_item)
dictionary[k] = formatted_list
else:
if type(dictionary[k]) == str:
dictionary[k] = dictionary[k].format(replace_value)
return dictionary
|
|
|
|
|
6191b56409da4f2d51541a3fc44a0ca10a01b642
|
|
|
|
app/src/main/java/alektas/telecomapp/utils/L.kt
|
|
1e83fbe6daa496f4c4f47d41f404d3e66fb200ff
|
|
|
|
|
app/src/main/java/alektas/telecomapp/utils/L.kt
|
|
1e83fbe6daa496f4c4f47d41f404d3e66fb200ff
|
|
|
|
|
app/src/main/java/alektas/telecomapp/utils/L.kt
|
|
1e83fbe6daa496f4c4f47d41f404d3e66fb200ff
|
|
|
|
|
package alektas.telecomapp.utils
import alektas.telecomapp.BuildConfig
class L {
companion object {
private const val MEASURING_TIME_TAG = "MEASURING_TIME"
private val startPoints = mutableListOf<Pair<String, Long>>()
fun d(log: String) {
if (BuildConfig.DEBUG) println(log)
}
fun d(where: Any, log: String) {
if (BuildConfig.DEBUG) println("[${Thread.currentThread().name}][${where.javaClass.simpleName}]: $log")
}
fun d(tag: String, log: String) {
if (BuildConfig.DEBUG) println("[${Thread.currentThread().name}][$tag]: $log")
}
/**
* Start measuring time. Invoke this method at the moment where you want to start measuring.
* To count time use [stop] method at right moment. It will log measured time to the Lagcat.
*/
fun start(pointName: String = "") {
d(MEASURING_TIME_TAG, "Start measuring from |Point-$pointName|")
startPoints.add(pointName to System.nanoTime())
}
/**
* Stop measuring time. Invoke this method at the moment where you want to stop measuring.
* To start measuring use [start] method at right moment.
* This method will log measured time to the Lagcat.
*/
fun stop() {
val endTime = System.nanoTime()
d(MEASURING_TIME_TAG, "*** Stop measuring ***")
startPoints.forEachIndexed { i, p ->
d(MEASURING_TIME_TAG, "Time from |Point-$i:${p.first}| |${(endTime - p.second) * 1.0e-9}| seconds")
}
startPoints.clear()
}
}
}
|
|
|
|
|
252a7e7fbadd13a20e101809c6dfe0bf95856270
|
|
|
|
src/main/kotlin/lain/Lexer.kt
|
|
6d5fbcc29da148fd72ecb58b164fc5c845267e5c
|
|
|
|
|
src/main/kotlin/lain/Lexer.kt
|
|
6d5fbcc29da148fd72ecb58b164fc5c845267e5c
|
|
|
|
|
src/main/kotlin/lain/Lexer.kt
|
|
6d5fbcc29da148fd72ecb58b164fc5c845267e5c
|
|
|
|
|
package lain
import java.time.Clock
class Lexer(val source: List<String>) {
private val tokens = mutableListOf<Token>()
private var start = 0
private var current = 0
fun scanTokens(): List<Token> {
while (!isAtEnd()) {
// we are at the beginning of the next lexeme
start = current
scanToken()
}
tokens.add(Token(TokenType.EOF, "", null))
return tokens.toList()
}
// scan one token maybe
private fun scanToken() {
val c:String = advance()
when (c) {
"\uD83E\uDD1C" -> addToken(TokenType.LEFT_PAREN)
"\uD83E\uDD1B" -> addToken(TokenType.RIGHT_PAREN)
"\uD83D\uDC49" -> addToken(TokenType.LEFT_BRACKET)
"\uD83D\uDC48" -> addToken(TokenType.RIGHT_BRACKET)
"〰" -> addToken(TokenType.COMMA)
else -> {
if (isDigit(c)) number()
else identifier(c)
}
}
}
// turns [0-9]+ into a token and adds it to token list
private fun number() {
while (ClockNumbers.isClock(peek())) advance()
addToken(TokenType.NUMBER, ClockNumbers.parseClocks(source.subList(start, current)))
}
// identifier is just 1 emoji
private fun identifier(c: String) {
addToken(TokenType.IDENTIFIER, c)
}
// consumes current character if matches expected, else returns false
private fun match(expected: String): Boolean {
if (isAtEnd()) return false
if (source[current] != expected) return false
current++
return true
}
// returns character without consuming it
private fun peek(): String {
if (isAtEnd()) return "\u0000"
return source[current]
}
// returns true if c is [0-9]
private fun isDigit(c: String): Boolean {
return ClockNumbers.isClock(c)
}
// returns true if at end of string source, false if not
private fun isAtEnd(): Boolean {
return current >= source.size
}
// advance the pointer and return the new current char
private fun advance(): String {
current++
return source[current - 1]
}
// adds a token to the list of tokens
private fun addToken(type: TokenType, literal: Any?) {
val text = source.subList(start, current).reduce { a, e -> a.plus(e) }
tokens.add(Token(type, text, literal))
}
private fun addToken(type: TokenType) {
addToken(type, null)
}
}
|
|
|
|
|
64e001a125c823bf162f4795a42b3d093c67a517
|
|
|
|
|
|
73a0715c25ffb6ae10885cde092748d0effc5457
|
|
|
|
|
|
|
73a0715c25ffb6ae10885cde092748d0effc5457
|
|
|
|
|
|
|
73a0715c25ffb6ae10885cde092748d0effc5457
|
|
|
|
|
const MAX_POINTS: u32 = 1000;
fn main() {
let i: i64 = 1;
println!("{}", i);
let f = 1.1; // default f64
let a = 1; // default i32
let cc = '\u{1F601}';
println!("{}", f);
println!("{}", a);
println!("{}", cc);
println!("{}", MAX_POINTS);
// while
let max = 10;
let mut num = 0;
while num * num < max {
println!("{0} * {0} = {1}", num, num * num);
num += 1;
}
let mut x = 1;
const MAX_NUM: i8 = 10;
while x < MAX_NUM {
// 允许重复定义相同变量名
let mut y = x;
while y < MAX_NUM {
print!("{}*{}={} ", x, y, x * y);
y += 1;
}
println!();
x += 1;
}
let mut num = 0;
// loop无限循环
loop {
println!("{0} * {0} = {1}", num, num * num);
num += 1;
if num * num > max {
break;
}
}
let t: bool = true;
println!("{}", t);
println!("--------------------------");
// tuple
let tup: (i32, i64) = (500, 1000);
println!("{}, {}", tup.0, tup.1);
let (x, y) = tup;
println!("{}, {}", x, y);
println!("--------------------------");
// array
let arr: [i32; 3] = [1, 2, 3];
println!("{}", arr[0]);
for elem in arr {
println!("arr: {}", elem)
}
println!("--------------------------");
// 控制流
let y = {
let x = 1;
x + 1
};
println!("{}", y);
let num = get_num();
println!("{}", num);
let condition = true;
let num = if condition {1} else {0};
println!("{}", num);
println!("--------------------------");
range_num();
let mut str = "hello";
println!("{}", str);
str = "rust";
println!("{}", str);
}
fn get_num() -> i32 {
6
}
fn range_num() {
for num in 1..6 { // 1-5
println!("{}", num)
}
}
|
|
|
|
|
3e817e4997df88adffabb8da5e0a76af8c34804c
|
|
|
|
|
|
f0e8be99b7dcd482708b9c928322bc07a3128506
|
|
|
|
|
|
|
f0e8be99b7dcd482708b9c928322bc07a3128506
|
|
|
|
|
|
|
f0e8be99b7dcd482708b9c928322bc07a3128506
|
|
|
|
|
// Copyright 2000-2021 Mark H. P. Lord
#ifndef PRIME_COMMANDLINEPARSER_H
#define PRIME_COMMANDLINEPARSER_H
#include "Config.h"
namespace Prime {
class Log;
/// A command line reader that supports short option (-v) and long options (--verbose), combined short options
/// (e.g., -v -n -r can be shortened to -vnr) and -- to mark the end of the options. In option names containing
/// a '-', the '-' is optional (e.g., --nocolour will match "no-colour"). A flag is an option that may be followed
/// by a '-' to disable it, e.g., -G- or --colours-, or a + to enable it. Long name flags can also be specified
/// with a "no-" or "disable-" prefix to negate them, e.g., --no-colours has the same result as --colours-. It is
/// also possible to use long options by default, e.g., -trace instead of --trace, by using
/// setImplicitLongOptionsEnabled(), which defaults to false. Values are options which expect one or more
/// parameters, e.g., --dest ~/Desktop.
class PRIME_PUBLIC CommandLineParser {
public:
CommandLineParser()
{
construct();
reset();
}
explicit CommandLineParser(char** argv)
{
construct();
init(argv);
}
virtual ~CommandLineParser();
/// Set the arguments to be read. The last element argv must be null (i.e., like the argument array which
/// is passed to main()). Note that returned strings are commonly pointers in to the strings in this array,
/// so the array must remain valid until the command line has been read.
bool init(char** argv);
class PRIME_PUBLIC ResponseFileLoader {
public:
virtual ~ResponseFileLoader() { }
/// Update ***argv to point to a new list of arguments to be parsed. The file name of the response file
/// comes from path, which may itself come from another response file.
virtual void loadResponseFile(const char* path, char*** argv, Log* log) = 0;
};
void setResponseFileLoader(char responseFileChar, ResponseFileLoader* responseFileLoader)
{
_responseFileChar = responseFileChar;
_responseFileLoader = responseFileLoader;
}
void reset();
/// If true, -trace will be considered to match --trace, rather than -t -r -a -c -e. Defaults to false. For
/// this to work, the application must check for the long options before the short options.
bool getImplicitLongOptionsEnabled() const { return _allowImplicitLongOptions; }
void setImplicitLongOptionsEnabled(bool enabled) { _allowImplicitLongOptions = enabled; }
/// Parse the next token from the argument list. Returns false if there are no more arguments to read.
bool next();
/// Returns true if a basic, not-an-option argument was read.
bool isFilename() const { return !_state.opt; }
/// If a file name was read, returns it.
const char* getFilename() const { return _state.opt ? NULL : _state.filename; }
/// Returns true if a "--" argument has been encountered, signifying that all remaining arguments are files.
bool hasOptionTerminatorBeenRead() const { return _state.noMoreOptions; }
/// Returns true if an option, value or flag was read.
bool isOption() const { return _state.opt ? true : false; }
/// Returns the option that hasn't been read (for use when reporting errors, don't compare this, use
/// readOption(), readFlag() or readValue()).
const char* getOption() const { return _state.opt; }
/// Returns the last option that was successfully read (with readOption(), readFlag() or readValue()).
const char* getCurrentOption() const { return _state.currentOption; }
/// Return the option or filename that was parsed.
const char* getOptionOrFilename() const { return _state.opt ? _state.opt : _state.filename; }
/// Returns true if the next argument is one of the | separated words. For example, for an archive utility
/// you might ask cl.readCommand("add|a"), which would match "add", "a", "--add" and "-a" (and "-add" if
/// implicit long options are enabled).
bool readCommand(const char* words);
/// Returns true if the specified option was read. e.g., readOption("verbose|v")
bool readOption(const char* option)
{
return readOptionOrValueOrFlag(option, NULL, false);
}
/// If the specified option was read, returns true and sets *flag to true or false depending on whether the
/// option was followed by a + or -, respectively. So -f or -f+ would set *flag to true, -f- to false.
/// If flag is NULL, the result is stored internally and can be read by calling getFlag().
bool readFlag(const char* option, bool* flag = NULL)
{
return readOptionOrValueOrFlag(option, flag ? flag : &_state.flag, false);
}
/// Returns the flag read by readFlag() (or readColourFlag()) if they were called with a NULL flag pointer.
bool getFlag() const { return _state.flag; }
/// Returns true if the specified option, which should have a value, was read. After calling this you should
/// call one of the fetch*() methods (fetchString(), fetchInt() etc.) to fetch the option's value. A value
/// differs from a plain option in that it may be followed by an '=' sign, e.g., `--path=/bin`, which could
/// also be supplied as `--path /bin` and `--path= /bin`. An option can have multiple values, e.g.,
/// `--offset 160 120`, and the fetch*() methods should be called for each.
bool readValue(const char* option)
{
return readOptionOrValueOrFlag(option, NULL, true);
}
/// Fetch a string from the command line. Exits if there are no more arguments.
const char* fetchString();
/// Fetch an intmax_t from the command line. Exits if there are no more arguments or the argument is invalid.
intmax_t fetchIntmax();
/// Fetch an int from the command line. Exits if there are no more arguments or the argument is invalid.
int fetchInt();
/// Fetch an intmax_t from the command line. If the next argument isn't a valid number, returns the default
/// value and leaves the next argument to be read.
intmax_t fetchOptionalIntmax(intmax_t defaultValue);
/// Fetch an int from the command line. If the next argument isn't a valid number, returns the default
/// value and leaves the next argument to be read.
int fetchOptionalInt(int defaultValue);
/// Fetch a float from the command line. Exits if there are no more arguments or the argument is invalid.
float fetchFloat();
/// Fetch a double from the command line. Exits if there are no more arguments or the argument is invalid.
double fetchDouble();
/// Fetch the next argument and convert the result to a bool. If there's no argument, or the next argument
/// begins with the switch character (- or /) then true is assumed, but if there is an argument then yes,
/// true, on, 1 and + are all considered true and no, false, off, 0 and - are all considered false. So,
/// -f 1, -f+, -f and even -f YES are all considered true. -f -x will be considered true, and -x will
/// correctly be read next.
bool fetchBool();
/// Reads the standard colour/no colour flags (colour|color|colours|colors|G).
bool readColourFlag(bool* flag = NULL);
void skipLongOption();
void skipShortOption();
/// Skip an option's value. If unlessOption is true, if the next argument begins with a - then treat it as
/// an option and don't skip it.
void skipValue(bool unlessOption = false)
{
(void)fetchArgument(unlessOption);
}
// You can overload exit(ExitReason) to change how these are handled.
void exitDueToMissingArgument() { exit(ExitReasonMissingArgument); }
void exitDueToInvalidArgument() { exit(ExitReasonInvalidArgument); }
void exitDueToUnknownOption() { exit(ExitReasonUnknownOption); }
void exitDueToUnexpectedArgument() { exit(ExitReasonUnexpectedArgument); }
void exitDueToUnknownOptionOrUnexpectedArgument() { exit(ExitReasonUnknownOptionOrUnexpectedArgument); }
protected:
enum ExitReason {
ExitReasonMissingArgument,
ExitReasonInvalidArgument,
ExitReasonUnknownOption,
ExitReasonUnexpectedArgument,
ExitReasonUnknownOptionOrUnexpectedArgument,
};
virtual void exit(ExitReason reason);
private:
void construct();
bool readOptionOrValueOrFlag(const char* option, bool* flag, bool hasParam);
static bool equalLongOptionName(const char* have, const char* want, const char*& ptr, bool hasParam, bool hasFlag);
const char* fetchArgument(bool optional);
struct State {
char** argv;
const char* opt;
const char* filename;
bool noMoreOptions;
bool isLongOption;
bool flag;
char currentOption[64];
} _state;
bool _allowImplicitLongOptions;
int _responseFileChar;
ResponseFileLoader* _responseFileLoader;
PRIME_UNCOPYABLE(CommandLineParser);
};
}
#endif
|
|
|
|
|
fb2b96accbc2fe2b0ca62463a37a0b609aa455d7
|
|
|
|
LinkedListIterator/linked_list_iterator_main.c
|
Nam-H-Nguyen/DataStructure
|
61c86abf47171aecc66ba39e33364d12b12f94c1
|
|
|
|
|
LinkedListIterator/linked_list_iterator_main.c
|
Nam-H-Nguyen/DataStructure
|
61c86abf47171aecc66ba39e33364d12b12f94c1
|
|
|
|
|
LinkedListIterator/linked_list_iterator_main.c
|
Nam-H-Nguyen/DataStructure
|
61c86abf47171aecc66ba39e33364d12b12f94c1
|
|
|
|
|
/*
* @file linked_list_iterator_main.c
*
* This file exercises the singly linked list and singly linked list
* iterators functions.
*
* @since Oct 24, 2018
* @author: Nam H. Nguyen
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include "linked_list_iterator.h"
/**
* Test LinkedListIterator functions
*/
void testLinkedListIterator(void) {
printf("\nstart testLinkedListIterator\n");
printf("initial list\n");
LinkedList *list = newLinkedList(5);
printLinkedList(list);
printf("list size: %ld\n", linkedListSize(list));
// add 5 nodes to the list
printf("\nAdding 5 values to list\n");
addLastLinkedListVal(list, "A");
addLastLinkedListVal(list, "B");
addLastLinkedListVal(list, "C");
addLastLinkedListVal(list, "D");
addLastLinkedListVal(list, "E");
printLinkedList(list);
printf("list size: %ld\n", linkedListSize(list));
printf("\nTraversing list forward with iterator\n");
LinkedListIterator *itr = newLinkedListIterator(list);
printf("iterator count: %ld\n", getLinkedListIteratorCount(itr));
printf("iterator avail: %ld\n", getLinkedListIteratorAvailable(itr));
while (hasNextLinkedListIteratorVal(itr)) {
const char *val;
if (getNextLinkedListIteratorVal(itr, &val)) {
printf("iterator next: \"%s\"\n", val);
} else {
printf("iterator next: unavailable\n");
}
}
printf("iterator count: %ld\n", getLinkedListIteratorCount(itr));
printf("iterator avail: %ld\n", getLinkedListIteratorAvailable(itr));
printf("\nMoving back one from end with iterator\n");
printf("iterator has prev: %s\n", hasPrevLinkedListIteratorVal(itr) ? "true" : "false");
const char *val;
if (getPrevLinkedListIteratorVal(itr, &val)) {
printf("iterator prev: \"%s\"\n", val);
} else {
printf("iterator prev: unavailable\n");
}
printf("iterator count: %ld\n", getLinkedListIteratorCount(itr));
printf("iterator avail: %ld\n", getLinkedListIteratorAvailable(itr));
printf("\nMoving forward one to end with iterator\n");
if (getNextLinkedListIteratorVal(itr, &val)) {
printf("iterator next: \"%s\"\n", val);
} else {
printf("iterator next: unavailable\n");
}
printf("iterator count: %ld\n", getLinkedListIteratorCount(itr));
printf("iterator avail: %ld\n", getLinkedListIteratorAvailable(itr));
printf("\nResetting iterator\n");
resetLinkedListIterator(itr);
printf("iterator has next: %s\n", hasNextLinkedListIteratorVal(itr) ? "true" : "false");
printf("iterator count: %ld\n", getLinkedListIteratorCount(itr));
printf("iterator avail: %ld\n", getLinkedListIteratorAvailable(itr));
printf("\nTrying to move back one from beginning with iterator\n");
printf("iterator has prev: %s\n", hasPrevLinkedListIteratorVal(itr) ? "true" : "false");
if (getPrevLinkedListIteratorVal(itr, &val)) {
printf("iterator prev: \"%s\"\n", val);
} else {
printf("iterator prev: unavailable\n");
}
printf("\nDeleting iterator and linked list\n");
deleteLinkedListIterator(itr);
deleteLinkedList(list);
printf("end testLinkedListIterator\n");
}
/**
* Test functions.
*/
int main(void) {
testLinkedListIterator();
printf("program exiting\n");
}
|
|
|
|
|
dc12fe3a72634b5363c218ab0b3d9830282fc7ea
|
|
|
|
causalinference/core/propensity.py
|
youngminju-phd/Causalinference
|
630e8fb195754a720da41791b725d3dadabfb257
|
|
|
|
|
causalinference/core/propensity.py
|
youngminju-phd/Causalinference
|
630e8fb195754a720da41791b725d3dadabfb257
|
|
|
|
|
causalinference/core/propensity.py
|
youngminju-phd/Causalinference
|
630e8fb195754a720da41791b725d3dadabfb257
|
|
|
|
|
from __future__ import division
import numpy as np
from scipy.optimize import fmin_bfgs
from itertools import combinations_with_replacement
import causalinference.utils.tools as tools
from .data import Dict
class Propensity(Dict):
"""
Dictionary-like class containing propensity score data.
Propensity score related data includes estimated logistic regression
coefficients, maximized log-likelihood, predicted propensity scores,
and lists of the linear and quadratic terms that are included in the
logistic regression.
"""
def __init__(self, data, lin, qua):
Z = form_matrix(data['X'], lin, qua)
Z_c, Z_t = Z[data['controls']], Z[data['treated']]
beta = calc_coef(Z_c, Z_t)
self._data = data
self._dict = dict()
self._dict['lin'], self._dict['qua'] = lin, qua
self._dict['coef'] = beta
self._dict['loglike'] = -neg_loglike(beta, Z_c, Z_t)
self._dict['fitted'] = sigmoid(Z.dot(beta))
self._dict['se'] = calc_se(Z, self._dict['fitted'])
def __str__(self):
table_width = 80
coefs = self._dict['coef']
ses = self._dict['se']
output = '\n'
output += 'Estimated Parameters of Propensity Score\n\n'
entries1 = ['', 'Coef.', 'S.e.', 'z', 'P>|z|',
'[95% Conf. int.]']
entry_types1 = ['string']*6
col_spans1 = [1]*5 + [2]
output += tools.add_row(entries1, entry_types1,
col_spans1, table_width)
output += tools.add_line(table_width)
entries2 = tools.gen_reg_entries('Intercept', coefs[0], ses[0])
entry_types2 = ['string'] + ['float']*6
col_spans2 = [1]*7
output += tools.add_row(entries2, entry_types2,
col_spans2, table_width)
lin = self._dict['lin']
for (lin_term, coef, se) in zip(lin, coefs[1:], ses[1:]):
entries3 = tools.gen_reg_entries('X'+str(lin_term),
coef, se)
output += tools.add_row(entries3, entry_types2,
col_spans2, table_width)
qua = self._dict['qua']
lin_num = len(lin)+1 # including intercept
for (qua_term, coef, se) in zip(qua, coefs[lin_num:],
ses[lin_num:]):
name = 'X'+str(qua_term[0])+'*X'+str(qua_term[1])
entries4 = tools.gen_reg_entries(name, coef, se)
output += tools.add_row(entries4, entry_types2,
col_spans2, table_width)
return output
class PropensitySelect(Propensity):
"""
Dictionary-like class containing propensity score data.
Propensity score related data includes estimated logistic regression
coefficients, maximized log-likelihood, predicted propensity scores,
and lists of the linear and quadratic terms that are included in the
logistic regression.
"""
def __init__(self, data, lin_B, C_lin, C_qua):
X_c, X_t = data['X_c'], data['X_t']
lin = select_lin_terms(X_c, X_t, lin_B, C_lin)
qua = select_qua_terms(X_c, X_t, lin, C_qua)
super(PropensitySelect, self).__init__(data, lin, qua)
def form_matrix(X, lin, qua):
N, K = X.shape
mat = np.empty((N, 1+len(lin)+len(qua)))
mat[:, 0] = 1 # constant term
current_col = 1
if lin:
mat[:, current_col:current_col+len(lin)] = X[:, lin]
current_col += len(lin)
for term in qua: # qua is a list of tuples of column numbers
mat[:, current_col] = X[:, term[0]] * X[:, term[1]]
current_col += 1
return mat
def sigmoid(x, top_threshold=100, bottom_threshold=-100):
high_x = (x >= top_threshold)
low_x = (x <= bottom_threshold)
mid_x = ~(high_x | low_x)
values = np.empty(x.shape[0])
values[high_x] = 1.0
values[low_x] = 0.0
values[mid_x] = 1/(1+np.exp(-x[mid_x]))
return values
def log1exp(x, top_threshold=100, bottom_threshold=-100):
high_x = (x >= top_threshold)
low_x = (x <= bottom_threshold)
mid_x = ~(high_x | low_x)
values = np.empty(x.shape[0])
values[high_x] = 0.0
values[low_x] = -x[low_x]
values[mid_x] = np.log(1 + np.exp(-x[mid_x]))
return values
def neg_loglike(beta, X_c, X_t):
return log1exp(X_t.dot(beta)).sum() + log1exp(-X_c.dot(beta)).sum()
def neg_gradient(beta, X_c, X_t):
return (sigmoid(X_c.dot(beta))*X_c.T).sum(1) - \
(sigmoid(-X_t.dot(beta))*X_t.T).sum(1)
def calc_coef(X_c, X_t):
K = X_c.shape[1]
neg_ll = lambda b: neg_loglike(b, X_c, X_t)
neg_grad = lambda b: neg_gradient(b, X_c, X_t)
logit = fmin_bfgs(neg_ll, np.zeros(K), neg_grad,
full_output=True, disp=False)
return logit[0]
def calc_se(X, phat):
H = np.dot(phat*(1-phat)*X.T, X)
return np.sqrt(np.diag(np.linalg.inv(H)))
def get_excluded_lin(K, included):
included_set = set(included)
return [x for x in range(K) if x not in included_set]
def get_excluded_qua(lin, included):
whole_set = list(combinations_with_replacement(lin, 2))
included_set = set(included)
return [x for x in whole_set if x not in included_set]
def calc_loglike(X_c, X_t, lin, qua):
Z_c = form_matrix(X_c, lin, qua)
Z_t = form_matrix(X_t, lin, qua)
beta = calc_coef(Z_c, Z_t)
return -neg_loglike(beta, Z_c, Z_t)
def select_lin(X_c, X_t, lin_B, C_lin):
# Selects, through a sequence of likelihood ratio tests, the
# variables that should be included linearly in propensity
# score estimation.
K = X_c.shape[1]
excluded = get_excluded_lin(K, lin_B)
if excluded == []:
return lin_B
ll_null = calc_loglike(X_c, X_t, lin_B, [])
def lr_stat_lin(lin_term):
ll_alt = calc_loglike(X_c, X_t, lin_B+[lin_term], [])
return 2 * (ll_alt - ll_null)
lr_stats = np.array([lr_stat_lin(term) for term in excluded])
argmax_lr = lr_stats.argmax()
if lr_stats[argmax_lr] < C_lin:
return lin_B
else:
new_term = [excluded[argmax_lr]]
return select_lin(X_c, X_t, lin_B+new_term, C_lin)
def select_lin_terms(X_c, X_t, lin_B, C_lin):
# Mostly a wrapper around function select_lin to handle cases that
# require little computation.
if C_lin <= 0:
K = X_c.shape[1]
return lin_B + get_excluded_lin(K, lin_B)
elif C_lin == np.inf:
return lin_B
else:
return select_lin(X_c, X_t, lin_B, C_lin)
def select_qua(X_c, X_t, lin, qua_B, C_qua):
# Selects, through a sequence of likelihood ratio tests, the
# variables that should be included quadratically in propensity
# score estimation.
excluded = get_excluded_qua(lin, qua_B)
if excluded == []:
return qua_B
ll_null = calc_loglike(X_c, X_t, lin, qua_B)
def lr_stat_qua(qua_term):
ll_alt = calc_loglike(X_c, X_t, lin, qua_B+[qua_term])
return 2 * (ll_alt - ll_null)
lr_stats = np.array([lr_stat_qua(term) for term in excluded])
argmax_lr = lr_stats.argmax()
if lr_stats[argmax_lr] < C_qua:
return qua_B
else:
new_term = [excluded[argmax_lr]]
return select_qua(X_c, X_t, lin, qua_B+new_term, C_qua)
def select_qua_terms(X_c, X_t, lin, C_qua):
# Mostly a wrapper around function select_qua to handle cases that
# require little computation.
if lin == []:
return []
if C_qua <= 0:
return get_excluded_qua(lin, [])
elif C_qua == np.inf:
return []
else:
return select_qua(X_c, X_t, lin, [], C_qua)
|
|
|
|
|