def test_is_one_of_false_hierarchy(self): t_liquid = RxType("liquid") t_water = RxType("water", t_liquid) t_lake = RxType("lake", t_water) type_set = RxTypeSet() type_set._types = {"liquid": t_liquid} self.assertFalse(type_set.is_one_of("liquid", ["water", "lake"]))
def __init__(self, printable_subset: Optional[Iterable[str]] = None) -> None: self.omit_types: Set[str] = set() self.omit_wrappers: Set[str] = set() self._rxtypes = RxTypeSet() self._char_sets = CharSets(self._rxtypes) self._rxwrappers = RxWrapperSet(self._char_sets, printable_subset)
def test_add(self): rxtype = RxType("liquid") type_set = RxTypeSet(init_types=False) type_set.add(rxtype) self.assertEqual(len(type_set._types), 1) self.assertEqual(type_set._types["liquid"], rxtype)
def test_is_of_false_unrelated(self): t_liquid = RxType("liquid") t_solid = RxType("solid") type_set = RxTypeSet() type_set._types = {"liquid": t_liquid, "solid": t_solid} self.assertFalse(type_set.is_of("solid", "liquid")) self.assertFalse(type_set.is_of("liquid", "solid"))
def test_is_of_excluded(self): t_liquid = RxType("liquid") t_water = RxType("water", t_liquid) type_set = RxTypeSet() type_set._types = {"liquid": t_liquid} with self.assertRaises(KeyError): type_set.is_of("water", "liquid")
def test_is_one_of_false_unrelated(self): t_liquid = RxType("liquid") t_solid = RxType("solid") t_gas = RxType("gas") t_plasma = RxType("plasma") type_set = RxTypeSet() type_set._types = {"plasma": t_plasma} self.assertFalse( type_set.is_one_of("plasma", ["liquid", "solid", "gas"]))
def test_is_one_of_true(self): t_liquid = RxType("liquid") t_solid = RxType("solid") t_gas = RxType("gas") t_water = RxType("water", t_liquid) type_set = RxTypeSet() type_set._types = {"water": t_water} self.assertTrue(type_set.is_one_of("water", ["liquid", "solid", "gas"]))
def test_is_of_true(self): t_liquid = RxType("liquid") t_water = RxType("water", t_liquid) t_lake = RxType("lake", t_water) type_set = RxTypeSet() type_set._types = {"water": t_water, "lake": t_lake} self.assertTrue(type_set.is_of("water", "liquid")) self.assertTrue(type_set.is_of("lake", "water"))
def test_init_types(self): type_set = RxTypeSet(init_types=False) type_set.init_types() for settings in RXTYPE_SETTINGS: self.assertIn(settings["name"], type_set._types) rxtype = type_set._types[settings["name"]] self.assertIsInstance(rxtype, RxType) self.assertEqual(rxtype.name, settings["name"])
def test_init_char_set_empty_subset(self): type_set = RxTypeSet() type_set.init_types() char_sets = CharSets(type_set) type_name = "alphanum" full_type_names = set(type_set.get_full_type_names(type_name)) printable_subset = set() char_set = CHAR_SETS[type_name] char_sets.init_char_set(type_name, printable_subset, char_set) # no characters should be activated from type name character set for char in char_set: for name in full_type_names: if name in char_sets._char_sets: self.assertNotIn(char, char_sets._char_sets[name])
def test_init_char_set(self): type_set = RxTypeSet() type_set.init_types() char_sets = CharSets(type_set) printable_subset = set(CHAR_SETS.keys()) for settings in RXWRAPPER_SETTINGS: if settings.get("is_char_set"): type_name = settings.get("rxtype_name", settings["name"]) char_set = settings.get("char_set") or CHAR_SETS[type_name] char_sets.init_char_set(type_name, printable_subset, char_set) for type_name in CHAR_SETS.keys(): self.assertIn(type_name, char_sets._char_sets) for char in CHAR_SETS[type_name]: self.assertIn(char, char_sets._char_sets[type_name])
def setUp(self): self.water_type = RxType("water") self.fire_type = RxType("fire") self.rxtypes = RxTypeSet() self.char_sets = CharSets(self.rxtypes) self.river_wrapper = RxWrapper("river", lambda node: "river", self.water_type) self.candle_wrapper = RxWrapper("candle", lambda node: "candle", self.fire_type)
def test_init_char_set_full_subset(self): type_set = RxTypeSet() type_set.init_types() char_sets = CharSets(type_set) type_name = "alphanum" full_type_names = set(type_set.get_full_type_names(type_name)) printable_subset = set(CHAR_SETS.keys()) char_set = CHAR_SETS[type_name] char_sets.init_char_set(type_name, printable_subset, char_set) # all related type names should contain all characters in alphanum char set for char in char_set: for name in full_type_names: # only evaluate those type names that represent actual printable character sets if name in char_sets._char_sets: self.assertIn(char, char_sets._char_sets[name])
def test_init(self): type_set = RxTypeSet() char_sets = CharSets(type_set) self.assertEqual(len(char_sets._char_sets), len(CHAR_SETS.keys())) for key in CHAR_SETS.keys(): self.assertIn(key, char_sets._char_sets) self.assertIsInstance(char_sets._char_sets[key], set) self.assertEqual(len(char_sets._char_sets[key]), 0) self.assertEqual(type_set, char_sets._rxtypes)
def test_init_char_set_partial_subset(self): type_set = RxTypeSet() type_set.init_types() char_sets = CharSets(type_set) type_names = ["digit", "alpha_lower", "alpha_upper"] printable_subset = set(["digit", "alpha_upper"]) # Initialise character sets for type_name in type_names: char_set = CHAR_SETS[type_name] char_sets.init_char_set(type_name, printable_subset, char_set) # Search through all specified type names for type_name in type_names: # Confirm that type name is present in charsets self.assertIn(type_name, char_sets._char_sets) # Get the full list of character set type names that the current type name inherits from (inluding itself) full_type_names = list( filter( lambda name: name in char_sets._char_sets, type_set.get_full_type_names(type_name), )) # For all characters in the character set corresponding to the current type name for char in CHAR_SETS[type_name]: # For all the character set types it inherits from (including itself) for name in full_type_names: # If the current type name is in the printable subset, it should be activated within the charset if type_name in printable_subset: self.assertIn(char, char_sets._char_sets[name]) # If the current type name is not in the printable subset, it should be excluded from the charset else: self.assertNotIn(char, char_sets._char_sets[name])
def test_empty_sets(self): type_set = RxTypeSet() char_sets = CharSets(type_set) for key in char_sets._char_sets.keys(): char_sets._char_sets[key].add("a") char_sets._char_sets[key].add("b") char_sets._char_sets[key].add("c") self.assertEqual(len(char_sets._char_sets[key]), 3) char_sets.empty_sets() self.assertEqual(len(char_sets._char_sets), len(CHAR_SETS.keys())) for key in char_sets._char_sets.keys(): self.assertEqual(len(char_sets._char_sets[key]), 0)
def test_get_full_type_names(self): t_liquid = RxType("liquid") t_water = RxType("water", t_liquid) t_lake = RxType("lake", t_water) type_set = RxTypeSet() type_set._types = { "liquid": t_liquid, "water": t_water, "lake": t_lake } self.assertEqual(type_set.get_full_type_names("liquid"), ["liquid"]) self.assertEqual(type_set.get_full_type_names("water"), ["water", "liquid"]) self.assertEqual(type_set.get_full_type_names("lake"), ["lake", "water", "liquid"])
class RxNodeFactory: def __init__(self, printable_subset: Optional[Iterable[str]] = None) -> None: self.omit_types: Set[str] = set() self.omit_wrappers: Set[str] = set() self._rxtypes = RxTypeSet() self._char_sets = CharSets(self._rxtypes) self._rxwrappers = RxWrapperSet(self._char_sets, printable_subset) def set_omit( self, types: Optional[Union[str, Iterable[str]]] = None, wrappers: Optional[Union[str, Iterable[str]]] = None, ) -> None: if types and not isinstance(types, set): types = set(types) self.omit_types = types or set() if wrappers and not isinstance(wrappers, set): wrappers = set(wrappers) self.omit_wrappers = wrappers or set() def clear_omit(self, types: bool = False, wrappers: bool = False) -> None: if not (types and wrappers): self.clear_omit(types=True, wrappers=True) if types: self.omit_types.clear() if wrappers: self.omit_wrappers.clear() def parse_rxspec(self, rxspec: RxSpec) -> NodeSpec: if not isinstance(rxspec, list): rxspec = [rxspec] node_spec = {"rw_name": rxspec[0]} for spec in rxspec[1:]: if self._rxwrappers.wrapper_is_type(first_nested(spec), "mod"): node_spec["modifier"] = self.parse_rxspec(spec) else: node_spec["children"] = [ self.parse_rxspec(child) for child in spec ] return node_spec def make_node( self, rw_name: Optional[str] = None, children: Union[List[NodeSpec], int] = RAND, modifier: Optional[Union[NodeSpec, int]] = None, rxwrapper: Optional[RxWrapper] = None, is_child: bool = False, strict_type_match: bool = False, ) -> RxNode: """ children format: [{'rw_name': regex_wrapper_name, 'children': [<children>]})] modifier format: {'rw_name': <modifier_name>, 'children': <children>, 'modifier': <modifier>} """ if not rxwrapper: if not rw_name: raise ValueError("must provide regex wrapper object or name") rxwrapper = self._rxwrappers[rw_name] child_nodes: List[RxNode] = [] if rxwrapper.child_count != 0: if children == RAND: child_types: List[str] = list( filter( lambda type_name: not self._rxtypes.is_one_of( type_name, self.omit_types), rxwrapper.child_types, )) if rxwrapper.uniform_child_types: child_types = sample(rxwrapper.child_types, 1) child_nodes = [ self.make_random_node(choice(child_types), is_child=True) for i in range(rxwrapper.get_child_count()) ] else: for child in children: child_nodes.append(self.make_node(**child, is_child=True)) node: RxNode = RxNode(self._char_sets, rxwrapper, child_nodes, is_child) if rxwrapper.is_modifiable: if modifier == RAND: # print("- ", node.name) # print("- ", rxwrapper.name) # print("- ", rxwrapper.rxtype) # print("- ", rxwrapper.rxtype.is_type_name("mod")) # if wrapper is not a modifier, build a modifier. Otherwise, build mod-modifier. mod_type: str = ("mmod" if rxwrapper.rxtype.is_type_name("mod") else "mod") # print("- ", mod_type) # if mod_type (to make) is mod, then don't build an mmod # omit_types += ["mmod"] if mod_type == "mod" else [] # print(">> ", omit_types) if mod_type not in self.omit_types: modifier_node: RxNode = self.make_random_node( mod_type, strict_typing=True) node.set_modifier(modifier_node) # print("-- ", modifier) elif modifier: modifier_node = self.make_node(**modifier) node.set_modifier(modifier_node) return node def make_random_node( self, type_name: str = "re", is_child: bool = False, prob_modifier: float = P_MODIFIER, strict_typing: bool = False, ) -> RxNode: rxtype: RxType = self._rxtypes[type_name] # filter RxWrapper.wrappers with items that match rxtype filtered_wrappers: List[RxWrapper] = list( filter( lambda rxwrapper: rxwrapper.rxtype.is_type( rxtype, strict=strict_typing), self._rxwrappers.all(), )) # filter out types specified for omission in node generation for omit in self.omit_types: omit_type: RxType = self._rxtypes[omit] filtered_wrappers = list( filter( lambda rxwrapper: not rxwrapper.rxtype.is_type(omit_type), filtered_wrappers, )) # filter out characters if is root node and suppression parameter specified if not is_child and SUPPRESS_ROOT_CHARS: filtered_wrappers = list( filter( lambda rxwrapper: not rxwrapper.rxtype.is_type( self._rxtypes["printable"]), filtered_wrappers, )) # filter out wrappers specified for omission in node generation for omit in self.omit_wrappers: filtered_wrappers = list( filter(lambda rxwrapper: rxwrapper.name != omit, filtered_wrappers)) rxwrapper: RxWrapper = choice(filtered_wrappers) modifier: Optional[int] = None if rxwrapper.is_modifiable and random() < prob_modifier: modifier = RAND return self.make_node( rxwrapper=rxwrapper, modifier=modifier, is_child=is_child, )
def setUp(self): self.rxtypes = RxTypeSet() self.char_sets = CharSets(self.rxtypes) self.rxwrappers = RxWrapperSet(self.char_sets)
def test_getitem(self): rxtype = RxType("liquid") type_set = RxTypeSet() type_set._types = {"liquid": rxtype} self.assertEqual(type_set["liquid"], rxtype)
def test_getitem(self): type_set = RxTypeSet() char_sets = CharSets(type_set) for key in CHAR_SETS.keys(): self.assertIsInstance(char_sets[key], set)
def test_rxtypes(self): type_set = RxTypeSet() char_sets = CharSets(type_set) result = char_sets.rxtypes() self.assertEqual(result, type_set)
def test_contains_false(self): type_set = RxTypeSet() char_sets = CharSets(type_set) self.assertFalse("INVALID_KEY" in char_sets) self.assertNotIn("INVALID_KEY", char_sets)
def test_contains_true(self): type_set = RxTypeSet() char_sets = CharSets(type_set) for key in CHAR_SETS.keys(): self.assertTrue(key in char_sets) self.assertIn(key, char_sets)