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)
