def generate(self, base_path, force_length=None):
if force_length is not None:
length = force_length
else:
length = weighted_choice(self._lengths)
type_extension_counts = collections.Counter()
for i in range(length):
type = weighted_choice(self._types)
if self._process_output_extensions:
extension = weighted_choice(self._output_extensions)
else:
extension = None
type_extension_counts.update([(type, extension)])
output = []
for (type, extension), count in type_extension_counts.items():
if self._process_output_extensions:
options = self._context.gen_targets_with_output_by_type[type]
options = [
x for x in options if self._get_output_extension(
self._context.gen_target_data[x]) == extension
]
else:
options = self._context.gen_targets_by_type[type]
if count > len(options):
raise GenerationFailedException()
output.extend(random.sample(options, count))
return GeneratedField(output, output)
def generate_string(self):
length = weighted_choice(self._lengths)
output = ''
if length > 0:
output += weighted_choice(self._first_chars)
while len(output) < length:
output += weighted_choice(self._other_chars)
return output
def generate(self, base_path, force_length=None):
if force_length is not None:
length = force_length
else:
length = weighted_choice(self._lengths)
extension = weighted_choice(self._extensions)
output = [self._generate_path(base_path, extension) for i in range(length)]
return GeneratedField(output, [])
def generate_string(self):
length = weighted_choice(self._lengths)
output = ''
if length > 0:
output += weighted_choice(self._first_chars)
while len(output) < length:
output += weighted_choice(self._other_chars)
return output
def generate(self, base_path):
length = weighted_choice(self._lengths)
options = collections.Counter(self._values)
output = []
while len(output) < length:
value = weighted_choice(options)
output.append(value)
del options[value]
return GeneratedField(output, [])
def generate(self, base_path):
length = weighted_choice(self._lengths)
options = collections.Counter(self._values)
output = []
while len(output) < length:
value = weighted_choice(options)
output.append(value)
del options[value]
return GeneratedField(output, [])
def generate_string(self):
length = weighted_choice(self._lengths)
output = ""
if length > 0:
output += weighted_choice(self._first_chars)
while len(output) < length:
output += weighted_choice(self._other_chars)
if self._respect_file_extensions:
output += weighted_choice(self._extensions)
return output
def generate_string(self):
length = weighted_choice(self._lengths)
output = ""
if length > 0:
output += weighted_choice(self._first_chars)
while len(output) < length:
output += weighted_choice(self._other_chars)
if self._respect_file_extensions:
output += weighted_choice(self._extensions)
return output
def _generate_source_with_flags(self, base_path, source_path):
flag_count = weighted_choice(self._flag_counts)
if flag_count == 0:
return source_path
flags = [self._flag_generator.generate(base_path).value
for i in range(flag_count)]
return [source_path, flags]
def generate(self, base_path, force_length=None):
if force_length is not None:
length = force_length
else:
length = weighted_choice(self._lengths)
type_counts = collections.Counter()
types = collections.Counter(self._types)
for i in range(length):
type_counts.update([weighted_choice(types)])
output = []
for type, count in type_counts.items():
options = self._context.gen_targets_by_type[type]
if count > len(options):
raise GenerationFailedException()
output.extend(random.sample(options, count))
return GeneratedField(output, output)
def _generate_parent(
self, package_key, root, depth, sizes_by_depth, component_generator
):
if depth == 0:
return "", root
key = (package_key, depth)
value = self._available_directories.get(key)
if value is not None:
key_found = True
path, directory, size = value
else:
key_found = False
parent_path, parent_dir = self._generate_parent(
package_key, root, depth - 1, sizes_by_depth, component_generator
)
name = self._generate_name(parent_dir, component_generator)
path = os.path.join(parent_path, name)
directory = {}
parent_dir[name.lower()] = directory
size = weighted_choice(sizes_by_depth[depth])
size -= 1
if size > 0:
self._available_directories[key] = (path, directory, size)
elif key_found:
del self._available_directories[key]
return path, directory
def _generate_parent(
self, package_key, root, depth, sizes_by_depth,
component_generator):
if depth == 0:
return '', root
key = (package_key, depth)
value = self._available_directories.get(key)
if value is not None:
key_found = True
path, directory, size = value
else:
key_found = False
parent_path, parent_dir = self._generate_parent(
package_key, root, depth - 1, sizes_by_depth,
component_generator)
name = self._generate_name(parent_dir, component_generator)
path = os.path.join(parent_path, name)
directory = {}
parent_dir[name.lower()] = directory
size = weighted_choice(sizes_by_depth[depth])
size -= 1
if size > 0:
self._available_directories[key] = (path, directory, size)
elif key_found:
del self._available_directories[key]
return path, directory
def generate(self, base_path, force_length=None):
if force_length is not None:
length = force_length
else:
length = weighted_choice(self._lengths)
type_counts = collections.Counter()
types = collections.Counter(self._types)
for i in range(length):
type_counts.update([weighted_choice(types)])
output = []
for type, count in type_counts.items():
options = self._context.gen_targets_by_type[type]
if count > len(options):
raise GenerationFailedException()
output.extend(random.sample(options, count))
return GeneratedField(output, output)
def generate_package_path(self):
if self._last_package_path is not None:
path = self._last_package_path
self._last_package_remaining_targets -= 1
if self._last_package_remaining_targets <= 0:
self._last_package_path = None
return path
depth = weighted_choice(self._package_depths)
path, parent_dir = self._generate_path('//', self._root, depth,
self._sizes_by_depth,
self._component_generator)
directory = {self.BUILD_FILE_NAME.lower(): None}
parent_dir[os.path.basename(path).lower()] = directory
self._last_package_path = path
self._last_package_remaining_targets = weighted_choice(
self._build_file_sizes) - 1
return path
def generate_package_path(self):
if self._last_package_path is not None:
path = self._last_package_path
self._last_package_remaining_targets -= 1
if self._last_package_remaining_targets <= 0:
self._last_package_path = None
return path
depth = weighted_choice(self._package_depths)
path, parent_dir = self._generate_path(
'//', self._root, depth, self._sizes_by_depth,
self._component_generator)
directory = {self.BUILD_FILE_NAME.lower(): None}
parent_dir[os.path.basename(path).lower()] = directory
self._last_package_path = path
self._last_package_remaining_targets = weighted_choice(
self._build_file_sizes) - 1
return path
def generate(self):
length = weighted_choice(self._lengths)
build_target_count = 0
path_count = 0
for i in range(length):
if weighted_choice(self._build_target_values):
build_target_count += 1
else:
path_count += 1
build_targets = self._build_target_set_generator.generate(
force_length=build_target_count)
paths = self._path_set_generator.generate(force_length=path_count)
assert len(
build_targets.value) == build_target_count, (build_targets,
build_target_count)
assert len(paths.value) == path_count, (paths, path_count)
return GeneratedField(build_targets.value + paths.value,
build_targets.deps + paths.deps)
def _generate_path(self, base_path, extension):
component_count = weighted_choice(self._component_counts)
path = self._context.file_path_generator.generate_path_in_package(
base_path, component_count, self._component_generator, extension
)
full_path = os.path.join(self._context.output_repository, base_path, path)
os.makedirs(os.path.dirname(full_path), exist_ok=True)
with open(full_path, "w"):
pass
return path
def _generate_path(self, base_path, extension):
component_count = weighted_choice(self._component_counts)
path = self._context.file_path_generator.generate_path_in_package(
base_path, component_count, self._component_generator, extension)
full_path = os.path.join(self._context.output_repository, base_path,
path)
os.makedirs(os.path.dirname(full_path), exist_ok=True)
with open(full_path, "w"):
pass
return path
def generate(self, base_path):
length = weighted_choice(self._lengths)
build_target_count = 0
path_count = 0
for i in range(length):
if weighted_choice(self._build_target_values):
build_target_count += 1
else:
path_count += 1
build_targets = self._build_target_set_generator.generate(
base_path, force_length=build_target_count)
paths = self._path_set_generator.generate(
base_path, force_length=path_count)
assert len(build_targets.value) == build_target_count, (
build_targets, build_target_count)
assert len(paths.value) == path_count, (paths, path_count)
return GeneratedField(
build_targets.value + paths.value,
build_targets.deps + paths.deps)
def generate(self, base_path, force_length=None):
if self._unique_values_dirty:
self._update_choice_probability()
self._unique_values_dirty = False
if force_length is not None:
length = force_length
else:
length = weighted_choice(self._lengths)
type_extension_counts = collections.Counter()
for i in range(length):
type = weighted_choice(self._types)
if self._process_output_extensions:
extension = weighted_choice(self._output_extensions_by_type[type])
else:
extension = None
type_extension_counts.update([(type, extension)])
output = []
if self._process_output_extensions:
all_targets_dict = self._context.gen_targets_with_output_by_type
accepted_targets_dict = self._accepted_targets_with_output_by_type
else:
all_targets_dict = self._context.gen_targets_by_type
accepted_targets_dict = self._accepted_targets_by_type
for (type, extension), count in type_extension_counts.items():
options = accepted_targets_dict.get(type)
if options is None:
options = self.DynamicFilteredList(
all_targets_dict[type], lambda x: self._is_accepted(x)
)
accepted_targets_dict[type] = options
options = options.get_values()
if extension is not None:
options = [
x
for x in options
if self._get_output_extension(self._context.gen_target_data[x])
== extension
]
if count > len(options):
raise GenerationFailedException()
output.extend(random.sample(options, count))
return GeneratedField(output, output)
def _generate_path(self):
component_count = weighted_choice(self._component_counts)
components = [
self._component_generator.generate().value
for i in range(component_count)
]
path = os.path.join(*components)
full_path = os.path.join(self._context.output_repository, path)
if os.path.exists(full_path):
raise GenerationFailedException()
try:
os.makedirs(os.path.dirname(full_path), exist_ok=True)
except (NotADirectoryError, FileExistsError):
raise GenerationFailedException()
with open(full_path, 'w'):
pass
return path
def _generate_path(self, base_path):
component_count = weighted_choice(self._component_counts)
components = [self._component_generator.generate(base_path).value
for i in range(component_count)]
path = os.path.join(*components)
full_path = os.path.join(
self._context.output_repository,
base_path,
path)
if os.path.exists(full_path):
raise GenerationFailedException()
try:
os.makedirs(os.path.dirname(full_path), exist_ok=True)
except (NotADirectoryError, FileExistsError):
raise GenerationFailedException()
with open(full_path, 'w'):
pass
return path
def generate(self, base_path):
if weighted_choice(self._null_values):
return GeneratedField(None, [])
else:
return self._value_generator.generate(base_path)
def generate(self, force_type=None):
if force_type is not None:
type = force_type
else:
type = weighted_choice(self._types)
return self._data_generators[type].generate()
def generate(self, force_type=None):
if force_type is not None:
type = force_type
else:
type = weighted_choice(self._types)
return self._data_generators[type].generate()
def generate(self, base_path):
if weighted_choice(self._null_values):
return GeneratedField(None, [])
else:
return self._value_generator.generate(base_path)
