immuneML.util package

Submodules

immuneML.util.AdaptiveImportHelper module

class immuneML.util.AdaptiveImportHelper.AdaptiveImportHelper

Bases: object

static parse_adaptive_germline_to_imgt(dataframe, organism)

static parse_germline(dataframe: pandas.DataFrame, gene_name_replacement: dict, germline_value_replacement: dict)

static preprocess_dataframe(dataframe: pandas.DataFrame, params: immuneML.IO.dataset_import.DatasetImportParams.DatasetImportParams)

immuneML.util.CompAIRRHelper module

class immuneML.util.CompAIRRHelper.CompAIRRHelper

Bases: object

static check_compairr_path(compairr_path)

static determine_compairr_path(compairr_path)

static get_cmd_args(compairr_params, input_file_list, result_path)

static get_repertoire_contents(repertoire, compairr_params)

static process_compairr_output_file(subprocess_result, compairr_params, result_path)

static write_repertoire_file(repertoire_dataset, filename, compairr_params)

immuneML.util.CompAIRRParams module

class immuneML.util.CompAIRRParams.CompAIRRParams(compairr_path: pathlib.Path, keep_compairr_input: bool, differences: int, indels: bool, ignore_counts: bool, ignore_genes: bool, threads: int, output_filename: str, log_filename: str)

Bases: object

compairr_path: pathlib.Path

differences: int

ignore_counts: bool

ignore_genes: bool

indels: bool

keep_compairr_input: bool

log_filename: str

output_filename: str

threads: int

immuneML.util.DistanceMetrics module

immuneML.util.DistanceMetrics.jaccard(vector1, vector2, tmp_vector=None)

immuneML.util.DistanceMetrics.morisita_horn(vector1, vector2, *args, **kwargs)

immuneML.util.DocEnumHelper module

class immuneML.util.DocEnumHelper.DocEnumHelper

Bases: object

static get_enum_names(enum)

static get_enum_names_and_values(enum)

immuneML.util.EncoderHelper module

class immuneML.util.EncoderHelper.EncoderHelper

Bases: object

static build_comparison_data(dataset: immuneML.data_model.dataset.RepertoireDataset.RepertoireDataset, params: immuneML.encodings.EncoderParams.EncoderParams, comparison_attributes, sequence_batch_size)

static build_comparison_params(dataset, comparison_attributes) → tuple

static check_positive_class_label(class_name, labels)

static get_current_dataset(dataset, context)

static prepare_training_ids(dataset: immuneML.data_model.dataset.Dataset.Dataset, params: immuneML.encodings.EncoderParams.EncoderParams)

static store(encoded_dataset, params: immuneML.encodings.EncoderParams.EncoderParams)

static sync_encoder_with_cache(cache_params: tuple, encoder_memo_func, encoder, param_names)

immuneML.util.FilenameHandler module

class immuneML.util.FilenameHandler.FilenameHandler

Bases: object

static get_dataset_name(class_name: str)

static get_filename(class_name: str, file_type: str)

converts the class name to snake case and appends given file type :param class_name: name of the class that will be stored in the file :param file_type: file extension: pickle, json :return: filename consisting of concatenated class_name in snake case and file type

static get_model_name(class_name: str, file_type: str = 'pickle')

immuneML.util.ImportHelper module

class immuneML.util.ImportHelper.ImportHelper

Bases: object

DATASET_FORMAT = 'iml_dataset'

static build_receptor_from_rows(first_row, second_row, identifier, chain_pair, metadata_columns)

static drop_empty_sequences(dataframe: pandas.DataFrame, import_empty_aa_sequences: bool, import_empty_nt_sequences: bool) → pandas.DataFrame

static drop_illegal_character_sequences(dataframe: pandas.DataFrame, import_illegal_characters: bool) → pandas.DataFrame

static extract_sequence_dataset_params(items=None, params=None) → dict

static get_chain_for_row(row)

static get_sequence_filenames(path: pathlib.Path, dataset_name: str)

static import_dataset(import_class, params: dict, dataset_name: str) → <module 'immuneML.data_model.dataset.Dataset' from '/Users/milenpa/PycharmProjects/BMIImmuneML/immuneML/data_model/dataset/Dataset.py'>

static import_items(import_class, path, params: immuneML.IO.dataset_import.DatasetImportParams.DatasetImportParams)

static import_receptors(df, params) → List[immuneML.data_model.receptor.Receptor.Receptor]

static import_receptors_by_id(df, identifier, chain_pair, metadata_columns) → List[immuneML.data_model.receptor.Receptor.Receptor]

static import_repertoire_dataset(import_class, params: immuneML.IO.dataset_import.DatasetImportParams.DatasetImportParams, dataset_name: str) → immuneML.data_model.dataset.RepertoireDataset.RepertoireDataset

Function to create a dataset from the metadata and a list of repertoire files and exports dataset pickle file

Parameters

• import_class – class to use for import

• params – instance of DatasetImportParams class which includes information on path, columns, result path etc.

• dataset_name – user-defined name of the dataset

Returns

RepertoireDataset object that was created

static import_sequence(row, metadata_columns=None) → immuneML.data_model.receptor.receptor_sequence.ReceptorSequence.ReceptorSequence

static import_sequence_dataset(import_class, params, dataset_name: str)

static is_illegal_sequence(sequence, legal_alphabet) → bool

static junction_to_cdr3(df: pandas.DataFrame, region_type: immuneML.data_model.receptor.RegionType.RegionType)

If RegionType is CDR3, the leading C and trailing W are removed from the sequence to match the IMGT CDR3 definition. This method alters the data in the provided dataframe.

static load_chains(df: pandas.DataFrame)

static load_chains_from_chains(df: pandas.DataFrame) → list

static load_chains_from_genes(df: pandas.DataFrame) → list

static load_dataset_if_exists(params: dict, processed_params, dataset_name: str)

static load_repertoire_as_object(import_class, metadata_row, params: immuneML.IO.dataset_import.DatasetImportParams.DatasetImportParams)

static load_sequence_dataframe(filepath, params, alternative_load_func=None)

static make_new_metadata_file(repertoires: list, metadata: pandas.DataFrame, result_path: pathlib.Path, dataset_name: str) → pathlib.Path

static prepare_frame_type_list(params: immuneML.IO.dataset_import.DatasetImportParams.DatasetImportParams) → list

static rename_dataframe_columns(df, params: immuneML.IO.dataset_import.DatasetImportParams.DatasetImportParams)

static safe_load_dataframe(filepath, params: immuneML.IO.dataset_import.DatasetImportParams.DatasetImportParams)

static standardize_none_values(dataframe: pandas.DataFrame)

static store_sequence_items(dataset_filenames: list, items: list, sequence_file_size: int)

static strip_alleles(df: pandas.DataFrame, column_name)

static strip_genes(df: pandas.DataFrame, column_name)

static strip_suffix(df: pandas.DataFrame, column_name, delimiter)

Safely removes everything after a delimiter from a column in the DataFrame

static update_gene_info(df: pandas.DataFrame)

Updates gene info in 2 steps:

• First, columns are added if they were not present. This is done by going from the highest level of information (alleles)

towards the lowest level of information (subgroups) by stripping away suffixes. If gene and subgroup columns were already present, suffixes are still stripped away just in case. - Next, if there are None values present, the highest possible level of information is copied in from the lower level information fields. This is done by moving from subgroups towards alleles. So if for one particular receptor only the subgroup was present, the subgroup will be copied into the genes and alleles column.

immuneML.util.KmerHelper module

class immuneML.util.KmerHelper.KmerHelper

Bases: object

static create_IMGT_gapped_kmers_from_sequence(sequence: immuneML.data_model.receptor.receptor_sequence.ReceptorSequence.ReceptorSequence, sequence_type: immuneML.environment.SequenceType.SequenceType, k_left: int, max_gap: int, k_right: Optional[int] = None, min_gap: int = 0)

static create_IMGT_kmers_from_sequence(sequence: immuneML.data_model.receptor.receptor_sequence.ReceptorSequence.ReceptorSequence, k: int, sequence_type: immuneML.environment.SequenceType.SequenceType)

static create_all_kmers(k: int, alphabet: list)

creates all possible k-mers given a k-mer length and an alphabet :param k: length of k-mer (int) :param alphabet: list of characters from which to make all possible k-mers (list) :return: alphabetically sorted list of k-mers

static create_gapped_kmers_from_sequence(sequence: immuneML.data_model.receptor.receptor_sequence.ReceptorSequence.ReceptorSequence, sequence_type: immuneML.environment.SequenceType.SequenceType, k_left: int, max_gap: int, k_right: Optional[int] = None, min_gap: int = 0)

static create_gapped_kmers_from_string(sequence, k_left: int, max_gap: int, k_right: Optional[int] = None, min_gap: int = 0)

static create_kmers_from_sequence(sequence: immuneML.data_model.receptor.receptor_sequence.ReceptorSequence.ReceptorSequence, k: int, sequence_type: immuneML.environment.SequenceType.SequenceType, overlap: bool = True)

static create_kmers_from_string(sequence, k: int, overlap: bool = True)

static create_kmers_within_HD(kmer: str, alphabet: list, distance: int = 1)

static create_sentences_from_repertoire(repertoire: immuneML.data_model.repertoire.Repertoire.Repertoire, k: int, sequence_type: immuneML.environment.SequenceType.SequenceType, overlap: bool = True)

immuneML.util.Logger module

immuneML.util.Logger.log(func)

immuneML.util.NameBuilder module

class immuneML.util.NameBuilder.NameBuilder

Bases: object

static build_name_from_dict(dictionary: dict, level=0)

Creates a name from dictionary which includes all of its parameters and handles nested dictionaries up to depth of 10 inclusively

Parameters

• dictionary (dict) – dictionary to create the name from

• level (int) – controls recursion level, user should keep default

Returns

name (str)

immuneML.util.NumpyHelper module

class immuneML.util.NumpyHelper.NumpyHelper

Bases: object

static get_numpy_representation(obj)

converts object to representation that can be stored without pickle enables in numpy arrays; if it is an object or a dict, it will be serialized to a json string

static group_structured_array_by(data, field)

static is_nan_or_empty(value)

static is_simple_type(t)

returns if the type t is string or a number so that it does not use pickle if serialized

immuneML.util.ParameterValidator module

class immuneML.util.ParameterValidator.ParameterValidator

Bases: object

static assert_all_in_valid_list(values: list, valid_values: list, location: str, parameter_name: str)

static assert_all_type_and_value(values, parameter_type, location: str, parameter_name: str, min_inclusive=None, max_inclusive=None)

static assert_in_valid_list(value, valid_values: list, location: str, parameter_name: str)

static assert_keys(keys, valid_keys, location: str, parameter_name: str, exclusive: bool = True)

static assert_keys_present(values: list, expected_values: list, location: str, parameter_name: str)

static assert_type_and_value(value, parameter_type, location: str, parameter_name: str, min_inclusive=None, max_inclusive=None, exact_value=None)

immuneML.util.PathBuilder module

class immuneML.util.PathBuilder.PathBuilder

Bases: object

static build(path, warn_if_exists=False)

immuneML.util.PositionHelper module

class immuneML.util.PositionHelper.PositionHelper

Bases: object

static adjust_position_weights(sequence_position_weights: dict, imgt_positions, limit: int) → dict

Parameters

• sequence_position_weights – weights supplied by the user as to where in the receptor_sequence to implant

• imgt_positions – IMGT positions present in the specific receptor_sequence

• limit – how far from the end of the receptor_sequence the motif at latest must start in order not to elongate the receptor_sequence

Returns

position_weights for implanting a motif instance into a receptor_sequence

static build_position_weights(sequence_position_weights: dict, imgt_positions, limit: int) → dict

static gen_imgt_positions_from_length(input_length: int)

static gen_imgt_positions_from_sequence(sequence: immuneML.data_model.receptor.receptor_sequence.ReceptorSequence.ReceptorSequence)

immuneML.util.ReflectionHandler module

class immuneML.util.ReflectionHandler.ReflectionHandler

Bases: object

static all_direct_subclasses(cls, drop_part=None, subdirectory=None)

static all_nonabstract_subclass_basic_names(cls, drop_part: str, subdirectory: str = '')

static all_nonabstract_subclasses(cls, drop_part=None, subdirectory=None)

static all_subclasses(cls)

static discover_classes_by_partial_name(class_name_ending: str, subdirectory: str = '')

static exists(class_name: str, subdirectory: str = '')

static get_class_by_name(class_name: str, subdirectory: str = '')

static get_class_from_path(path, class_name: Optional[str] = None)

obtain the class reference from the given path

Parameters

• path (str or pathlib.Path) – path to file where the class is located

• class_name (str) – class name to import_dataset from the file; if None, it is assumed that the class name is the same as the file name

Returns

class

static get_classes_by_partial_name(class_name_ending: str, subdirectory: str = '')

static import_function(function: str, module)

static import_module(name: str, package: Optional[str] = None)

static is_installed(module_name: str) → bool

immuneML.util.RepertoireBuilder module

class immuneML.util.RepertoireBuilder.RepertoireBuilder

Bases: object

Helper class for tests: creates repertoires from a list of a list of sequences and stores them in the given path

static build(sequences: list, path: pathlib.Path, labels: Optional[dict] = None, seq_metadata: Optional[list] = None, subject_ids: Optional[list] = None)

immuneML.util.SequenceAnalysisHelper module

class immuneML.util.SequenceAnalysisHelper.SequenceAnalysisHelper

Bases: object

static compute_overlap_matrix(hp_items: List[immuneML.hyperparameter_optimization.states.HPItem.HPItem])

immuneML.util.StringHelper module

class immuneML.util.StringHelper.StringHelper

Bases: object

static camel_case_to_word_string(camel_case_string: str)

static camel_case_to_words(camel_case_string: str)

immuneML.util.TCRdistHelper module

class immuneML.util.TCRdistHelper.TCRdistHelper

Bases: object

static add_default_allele_to_v_gene(v_gene: str)

static compute_tcr_dist(dataset: immuneML.data_model.dataset.ReceptorDataset.ReceptorDataset, labels: list, cores: int = 1)

static prepare_tcr_dist_dataframe(dataset: immuneML.data_model.dataset.ReceptorDataset.ReceptorDataset, labels: list) → pandas.DataFrame

Module contents