def buy_test_shares(self): self.test_shares = self.test_cash / self.test_df.Close[ self.test_cur_row] self.test_cash = 0 output( f"Bought {self.test_shares} shares at {self.test_df.Close[self.test_cur_row]}", self.output_file_path)
def main(): particles = [] ids = {} names = {} types = load_minecraft_json("protocol.json", "1.16")["types"]["particleData"][1]['fields'] print(types) for particle in load_minecraft_json("particles.json", "1.16"): variant = camel_case(particle['name']) id = str(particle['id']) if id in types.keys(): data = types[id] print(data[1]) particles.append(generate_particle_data(variant, data[1])) else: particles.append(variant) ids[variant] = id names[variant] = particle['name'] output_data = generate_enum("Particle", particles) output_data += generate_enum_property("Particle", "id", "u32", ids, True) output_data += generate_enum_property("Particle", "name", "&str", names, True, "&'static str") output("crates/core/src/particle.rs", output_data)
def update_portfolio_value(self): self.portfolio_value = self.shares * self.df.Close[ self.cur_row] + self.cash if self.portfolio_value >= self.max_portfolio_value: self.max_portfolio_value = self.portfolio_value self.max_portfolio_date = self.df.Date[self.cur_row] if self.portfolio_value <= self.min_portfolio_value: self.min_portfolio_value = self.portfolio_value self.min_portfolio_date = self.df.Date[self.cur_row] output( f"Updated portfolio value to {'${:,.2f}'.format(self.portfolio_value)}", self.output_file_path)
def run(self): for i in range(self.test_cur_row, self.test_df.Date.size): self.cur_date = self.test_df.Date[i] self.test_cur_row = i output(f"Date: {self.test_df.Date[self.test_cur_row]}", self.output_file_path) if not self.test_shares: self.buy_test_shares() if not self.control_shares: self.buy_control_shares() self.update_portfolio_value() if self.cur_date == self.end_date: break output( f"Final portfolio value: {'${:,.2f}'.format(self.portfolio_value)}", self.output_file_path) output( f"Highest value: {'${:,.2f}'.format(self.max_portfolio_value)} on {self.max_portfolio_date}", self.output_file_path) output( f"Lowest value: {'${:,.2f}'.format(self.min_portfolio_value)} on {self.min_portfolio_date}", self.output_file_path) pct_change = get_pct_change_str(start=self.config['starting_cash'], end=self.portfolio_value) os.rename(self.output_file_path, f"{self.output_file_path}_{pct_change}")
def report(self): if self.errors == 0: common.output(u" ✓ All tests passed.\n") elif self.errors == 1: common.output(u" ✗ 1 test failed.\n") else: common.output(u" ✗ {} tests failed.\n".format(self.errors))
def report(self): if self.errors == 0: common.output(u" ✓ Superáronse todas as probas.\n") elif self.errors == 1: common.output(u" ✗ Non se pasou unha das probas.\n") else: common.output(u" ✗ Non se pasaron {} das probas.\n".format(self.errors))
internal_ids = {} names = {} display_names = {} bboxes = {} for entity in load_minecraft_json("entities.json"): variant = camel_case(entity['name']) entities.append(variant) ids[variant] = entity['id'] internal_ids[variant] = entity['internalId'] names[variant] = entity['name'] display_names[variant] = entity['displayName'] width = entity['width'] height = entity['height'] bboxes[ variant] = f"vek::Aabb {{ min: vek::Vec3::zero(), max: vek::Vec3::new({width} as f64, {height} as f64, {width} as f64), }}" output_data = generate_enum("EntityKind", entities) output_data += generate_enum_property("EntityKind", "id", "u32", ids, True) output_data += generate_enum_property("EntityKind", "internal_id", "u32", internal_ids, True) output_data += generate_enum_property("EntityKind", "name", "&str", names, True, "&'static str") output_data += generate_enum_property("EntityKind", "display_name", "&str", display_names, True, "&'static str") output_data += generate_enum_property("EntityKind", "bounding_box", "vek::Aabb<f64>", bboxes) output("crates/core/src/entity.rs", output_data)
data = common.load_minecraft_json("biomes.json") variants = [] ids = {} names = {} display_names = {} rainfalls = {} temperatures = {} for biome in data: variant = common.camel_case(biome['name']) variants.append(variant) ids[variant] = biome['id'] names[variant] = biome['name'] display_names[variant] = biome['displayName'] rainfalls[variant] = biome['rainfall'] temperatures[variant] = biome['temperature'] output = common.generate_enum("Biome", variants) output += common.generate_enum_property("Biome", "id", "u32", ids, True) output += common.generate_enum_property("Biome", "name", "&str", names, True, "&'static str") output += common.generate_enum_property("Biome", "display_name", "&str", display_names, True, "&'static str") output += common.generate_enum_property("Biome", "rainfall", "f32", rainfalls) output += common.generate_enum_property("Biome", "temperature", "f32", temperatures) common.output("src/biome.rs", output)
}} """ output_data += f""" use std::convert::Into; impl Into<&'static str> for Item {{ fn into(self) -> &'static str {{ self.name() }} }} """ output_data += f""" use std::str::FromStr; impl FromStr for Item {{ type Err = &'static str; fn from_str(s: &str) -> Result<Self, Self::Err> {{ if let Some(item) = Item::from_name(s) {{ Ok(item) }} else {{ Err("Unknown item name.") }} }} }} """ output("items/src/item.rs", output_data)
Some(TOOLS) """ output_data = "#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive)]" + generate_enum( "BlockKind", blocks) output_data += generate_enum_property("BlockKind", "id", "u32", ids, True) output_data += generate_enum_property("BlockKind", "name", "&str", names, True, "&'static str") output_data += generate_enum_property("BlockKind", "display_name", "&str", display_names, True, "&'static str") output_data += generate_enum_property("BlockKind", "hardness", "f32", hardnesses) output_data += generate_enum_property("BlockKind", "diggable", "bool", diggables) output_data += generate_enum_property("BlockKind", "transparent", "bool", transparents) output_data += generate_enum_property("BlockKind", "light_emission", "u8", light_emissions) output_data += generate_enum_property("BlockKind", "light_filter", "u8", light_filters) output_data += generate_enum_property("BlockKind", "solid", "bool", solids) output_data += material_constants output_data += generate_enum_property( "BlockKind", "dig_multipliers", "&'static [(libcraft_items::Item, f32)]", dig_multipliers) output_data += generate_enum_property( "BlockKind", "harvest_tools", "Option<&'static [libcraft_items::Item]>", harvest_tools) output("crates/blocks/src/block.rs", output_data)
import common as common data = common.load_minecraft_json("particles.json", "1.16") particles = [] ids = {} names = {} for particle in data: variant = common.camel_case(particle['name']) particles.append(variant) ids[variant] = particle['id'] names[variant] = particle['name'] output = common.generate_enum("Particle", particles) output += common.generate_enum_property("Particle", "id", "u32", ids, True) output += common.generate_enum_property("Particle", "name", "&str", names, True, "&'static str") common.output("src/particle.rs", output)
regexes = {} for name, regex in simplified_block['regexes'].items(): regexes[name] = compile(regex) variants = [] mapping = {} for name in regexes: variants.append(camel_case(name)) for block in blocks: name = block['name'] block_variant = camel_case(name) # Detect which SimplifiedBlockKind matches this block. found = False for simplified, regex in regexes.items(): if regex.match(name) is not None: mapping[block_variant] = "SimplifiedBlockKind::" + camel_case(simplified) found = True break if not found: # Default to block variant variants.append(block_variant) mapping[block_variant] = "SimplifiedBlockKind::" + block_variant output_data = "use crate::BlockKind;" + generate_enum("SimplifiedBlockKind", variants) output_data += generate_enum_property("BlockKind", "simplified_kind", "SimplifiedBlockKind", mapping) output("blocks/src/simplified_block.rs", output_data)
def guess_ini(M): guess = OrderedDict() for idx in range(len(M)): guess[M[idx].strip().split(',')[0]] = ['DEL' for i in range(12)] return guess def eval(M, T_sub, S): sig_S = sig_gen(S, ATTR) guess = guess_ini(M) for idx in range(len(T_sub)): t_sub_gyo = T_sub[idx].strip().split(',') value= ':'.join([t_sub_gyo[i] for i in range(len(t_sub_gyo)) if i in ATTR]) cus_id = t_sub_gyo[0] if value in sig_S.keys(): guess[cus_id][month_passed(t_sub_gyo[2])]=sig_S[value] return [cus_id+","+",".join(guess[cus_id]) for cus_id in guess.keys()] def drop(S, num): for idx in range(len(S)): S_gyo = S[idx].strip().split(',') S_gyo[4] = S_gyo[4][0:min(len(S_gyo[4]), num)] S[idx] = ','.join(S_gyo) return S if __name__ == '__main__': M,S,T_sub = common.input(3) if 4 in ATTR: # 4は商品IDについての属性 S = drop(S, 2) common.output([eval(M, T_sub, S)])
"""Generation of the Biome enum. Uses minecraft-data/biomes.json.""" from common import load_minecraft_json, camel_case, generate_enum, generate_enum_property, output variants = [] ids = {} names = {} display_names = {} rainfalls = {} temperatures = {} for biome in load_minecraft_json("biomes.json"): variant = camel_case(biome['name']) variants.append(variant) ids[variant] = biome['id'] names[variant] = biome['name'] display_names[variant] = biome['displayName'] rainfalls[variant] = biome['rainfall'] temperatures[variant] = biome['temperature'] output_data = generate_enum("Biome", variants) output_data += generate_enum_property("Biome", "id", "u32", ids, True) output_data += generate_enum_property("Biome", "name", "&str", names, True, "&'static str") output_data += generate_enum_property("Biome", "display_name", "&str", display_names, True, "&'static str") output_data += generate_enum_property("Biome", "rainfall", "f32", rainfalls) output_data += generate_enum_property("Biome", "temperature", "f32", temperatures) output("crates/core/src/biome.rs", output_data)
regexes[name] = compile(regex) variants = [] mapping = {} for name in regexes: variants.append(camel_case(name)) for block in blocks: name = block['name'] block_variant = camel_case(name) # Detect which SimplifiedBlockKind matches this block. found = False for simplified, regex in regexes.items(): if regex.match(name) is not None: mapping[block_variant] = "SimplifiedBlockKind::" + camel_case( simplified) found = True break if not found: # Default to block variant variants.append(block_variant) mapping[block_variant] = "SimplifiedBlockKind::" + block_variant output_data = "use crate::BlockKind;" + generate_enum("SimplifiedBlockKind", variants) output_data += generate_enum_property("BlockKind", "simplified_kind", "SimplifiedBlockKind", mapping) output("crates/blocks/src/simplified_block.rs", output_data)
display_names = {} stack_sizes = {} durabilities = {} for item in data: variant = common.camel_case(item['name']) items.append(variant) ids[variant] = item['id'] names[variant] = item['name'] display_names[variant] = item['displayName'] stack_sizes[variant] = item['stackSize'] durability = item.get('durability') if durability is None: durabilities[variant] = "None" else: durabilities[variant] = f"Some({durability})" output = common.generate_enum("Item", items) output += common.generate_enum_property("Item", "id", "u32", ids, True) output += common.generate_enum_property("Item", "name", "&str", names, True, "&'static str") output += common.generate_enum_property("Item", "display_name", "&str", display_names, True, "&'static str") output += common.generate_enum_property("Item", "stack_size", "u32", stack_sizes) output += common.generate_enum_property("Item", "durability", "Option<u32>", durabilities) common.output("src/item.rs", output)
variants = [] mapping = {} for name in regexes: variants.append(common.camel_case(name)) for block in blocks: name = block['name'] block_variant = common.camel_case(name) # Detect which SimplifiedBlockKind matches this block. found = False for simplified, regex in regexes.items(): if regex.match(name) is not None: mapping[ block_variant] = "SimplifiedBlockKind::" + common.camel_case( simplified) found = True break if not found: # Default to block variant variants.append(block_variant) mapping[block_variant] = "SimplifiedBlockKind::" + block_variant output = "use crate::BlockKind;" + common.generate_enum( "SimplifiedBlockKind", variants) output += common.generate_enum_property("BlockKind", "simplified_kind", "SimplifiedBlockKind", mapping) common.output("src/simplified_block.rs", output)
"""Generation of the Biome enum. Uses minecraft-data/biomes.json.""" from common import load_minecraft_json, camel_case, generate_enum, generate_enum_property, output variants = [] ids = {} names = {} display_names = {} rainfalls = {} temperatures = {} for biome in load_minecraft_json("biomes.json"): variant = camel_case(biome['name']) variants.append(variant) ids[variant] = biome['id'] names[variant] = biome['name'] display_names[variant] = biome['displayName'] rainfalls[variant] = biome['rainfall'] temperatures[variant] = biome['temperature'] output_data = generate_enum("Biome", variants) output_data += generate_enum_property("Biome", "id", "u32", ids, True) output_data += generate_enum_property("Biome", "name", "&str", names, True, "&'static str") output_data += generate_enum_property("Biome", "display_name", "&str", display_names, True, "&'static str") output_data += generate_enum_property("Biome", "rainfall", "f32", rainfalls) output_data += generate_enum_property("Biome", "temperature", "f32", temperatures) output("core/src/biome.rs", output_data)
from common import load_minecraft_json, output, generate_enum, generate_enum_property, camel_case particles = [] ids = {} names = {} for particle in load_minecraft_json("particles.json", "1.16"): variant = camel_case(particle['name']) particles.append(variant) ids[variant] = particle['id'] names[variant] = particle['name'] output_data = generate_enum("Particle", particles) output_data += generate_enum_property("Particle", "id", "u32", ids, True) output_data += generate_enum_property("Particle", "name", "&str", names, True, "&'static str") output("crates/core/src/particle.rs", output_data)
internal_ids = {} names = {} display_names = {} bboxes = {} for entity in load_minecraft_json("entities.json"): variant = camel_case(entity['name']) entities.append(variant) ids[variant] = entity['id'] internal_ids[variant] = entity['internalId'] names[variant] = entity['name'] display_names[variant] = entity['displayName'] width = entity['width'] height = entity['height'] bboxes[ variant] = f"vek::Aabb {{ min: vek::Vec3::zero(), max: vek::Vec3::new({width} as f64, {height} as f64, {width} as f64), }}" output_data = generate_enum("EntityKind", entities) output_data += generate_enum_property("EntityKind", "id", "u32", ids, True) output_data += generate_enum_property("EntityKind", "internal_id", "u32", internal_ids, True) output_data += generate_enum_property("EntityKind", "name", "&str", names, True, "&'static str") output_data += generate_enum_property("EntityKind", "display_name", "&str", display_names, True, "&'static str") output_data += generate_enum_property("EntityKind", "bounding_box", "vek::Aabb<f64>", bboxes) output("core/src/entity.rs", output_data)
internal_ids = {} names = {} display_names = {} bboxes = {} for entity in data: variant = common.camel_case(entity['name']) entities.append(variant) ids[variant] = entity['id'] internal_ids[variant] = entity['internalId'] names[variant] = entity['name'] display_names[variant] = entity['displayName'] width = entity['width'] height = entity['height'] bboxes[ variant] = f"vek::Aabb {{ min: vek::Vec3::zero(), max: vek::Vec3::new({width} as f64, {height} as f64, {width} as f64), }}" output = common.generate_enum("EntityKind", entities) output += common.generate_enum_property("EntityKind", "id", "u32", ids, True) output += common.generate_enum_property("EntityKind", "internal_id", "u32", internal_ids, True) output += common.generate_enum_property("EntityKind", "name", "&str", names, True, "&'static str") output += common.generate_enum_property("EntityKind", "display_name", "&str", display_names, True, "&'static str") output += common.generate_enum_property("EntityKind", "bounding_box", "vek::Aabb<f64>", bboxes) common.output("src/entity.rs", output)
Some(TOOLS) """ output = "#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive)]" + common.generate_enum( "BlockKind", blocks) output += common.generate_enum_property("BlockKind", "id", "u32", ids, True) output += common.generate_enum_property("BlockKind", "name", "&str", names, True, "&'static str") output += common.generate_enum_property("BlockKind", "display_name", "&str", display_names, True, "&'static str") output += common.generate_enum_property("BlockKind", "hardness", "f32", hardnesses) output += common.generate_enum_property("BlockKind", "diggable", "bool", diggables) output += common.generate_enum_property("BlockKind", "transparent", "bool", transparents) output += common.generate_enum_property("BlockKind", "light_emission", "u8", light_emissions) output += common.generate_enum_property("BlockKind", "light_filter", "u8", light_filters) output += common.generate_enum_property("BlockKind", "solid", "bool", solids) output += material_constants output += common.generate_enum_property("BlockKind", "dig_multipliers", "&'static [(crate::Item, f32)]", dig_multipliers) output += common.generate_enum_property("BlockKind", "harvest_tools", "Option<&'static [crate::Item]>", harvest_tools) common.output("src/block.rs", output)
Some(TOOLS) """ output_data = "#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, serde::Serialize, serde::Deserialize)]" + \ generate_enum("BlockKind", blocks) output_data += generate_enum_property("BlockKind", "id", "u32", ids, True) output_data += generate_enum_property("BlockKind", "name", "&str", names, True, "&'static str") output_data += generate_enum_property("BlockKind", "display_name", "&str", display_names, True, "&'static str") output_data += generate_enum_property("BlockKind", "hardness", "f32", hardnesses) output_data += generate_enum_property("BlockKind", "diggable", "bool", diggables) output_data += generate_enum_property("BlockKind", "transparent", "bool", transparents) output_data += generate_enum_property("BlockKind", "light_emission", "u8", light_emissions) output_data += generate_enum_property("BlockKind", "light_filter", "u8", light_filters) output_data += generate_enum_property("BlockKind", "solid", "bool", solids) output_data += material_constants output_data += generate_enum_property( "BlockKind", "dig_multipliers", "&'static [(libcraft_items::Item, f32)]", dig_multipliers) output_data += generate_enum_property( "BlockKind", "harvest_tools", "Option<&'static [libcraft_items::Item]>", harvest_tools) output("blocks/src/block.rs", output_data)
items = [] ids = {} names = {} display_names = {} stack_sizes = {} durabilities = {} for item in load_minecraft_json("items.json", "1.16.2"): variant = camel_case(item['name']) items.append(variant) ids[variant] = item['id'] names[variant] = item['name'] display_names[variant] = item['displayName'] stack_sizes[variant] = item['stackSize'] durability = item.get('durability') if durability is None: durabilities[variant] = "None" else: durabilities[variant] = f"Some({durability})" output_data = "#[derive(serde::Serialize, serde::Deserialize)]" + generate_enum("Item", items) output_data += generate_enum_property("Item", "id", "u32", ids, True) output_data += generate_enum_property("Item", "name", "&str", names, True, "&'static str") output_data += generate_enum_property("Item", "display_name", "&str", display_names, False, "&'static str") output_data += generate_enum_property("Item", "stack_size", "u32", stack_sizes) output_data += generate_enum_property("Item", "durability", "Option<u32>", durabilities) output("crates/items/src/item.rs", output_data)
for area in areas: match_arm += f"{area}," match_arm += "}" get_area_fn += f"{match_arm} => match area {{" for area in areas: area_variant = common.camel_case(area) get_area_fn += f"Area::{area_variant} => Some({area}.as_ref())," get_area_fn += "_ => None }," get_areas_fn += f"\nInventoryBacking::{variant} {{ .. }} => {{static AREAS: [Area; {len(areas)}] = [" for area in areas: get_areas_fn += f"Area::{common.camel_case(area)}," get_areas_fn += f"];\n &AREAS }}," constructor_fn = f"pub fn {name}() -> Self where T: Default {{ InventoryBacking::{variant} {{" for area in areas: constructor_fn += f"{area}: Default::default()," constructor_fn += "} }\n" constructor_fns += constructor_fn inventory_constructor_fns += f"pub fn {name}() -> Self {{ Self {{ backing: std::sync::Arc::new(InventoryBacking::{name}()) }} }}" get_area_fn += "} }" get_areas_fn += "} }" output += f"impl <T> InventoryBacking<T> {{ {get_area_fn} {get_areas_fn} {constructor_fns} }}" output += f"impl crate::Inventory {{ {inventory_constructor_fns} }}" common.output("inventory/src/inventory.rs", output)