Package `geofetch` Documentation

Package Overview

The geofetch package provides tools for downloading metadata and data from Gene Expression Omnibus (GEO) and Sequence Read Archive (SRA). It can convert GEO/SRA metadata into PEP format for easy integration with other PEPkit tools.

Key Features

GEO/SRA Download: Fetch metadata and raw data from NCBI repositories
PEP Generation: Automatically create PEP-formatted project configs
Flexible Filtering: Search and filter GEO datasets by date and criteria
SRA Integration: Download and convert SRA data to FASTQ format
Processed Data: Download processed data matrices from GEO

Installation

pip install geofetch

Quick Example

from geofetch import Geofetcher

# Initialize geofetcher
gf = Geofetcher()

# Fetch a GEO series
gf.fetch_all(input="GSE####", name="my_project")

API Reference

Geofetcher Class

The main class for fetching data from GEO/SRA:

Geofetcher

Geofetcher(name='', metadata_root='', metadata_folder='', just_metadata=False, refresh_metadata=False, config_template=None, pipeline_samples=None, pipeline_project=None, skip=0, acc_anno=False, use_key_subset=False, processed=False, data_source='samples', filter=None, filter_size=None, geo_folder='.', split_experiments=False, bam_folder='', fq_folder='', sra_folder='', bam_conversion=False, picard_path='', input=None, const_limit_project=50, const_limit_discard=1000, attr_limit_truncate=500, max_soft_size='1GB', discard_soft=False, add_dotfile=False, disable_progressbar=False, add_convert_modifier=False, opts=None, max_prefetch_size=None, **kwargs)

Class to download or get projects, metadata, data from GEO and SRA

Constructor

:param input: GSEnumber or path to the input file :param name: Specify a project name. Defaults to GSE number or name of accessions file name :param metadata_root: Specify a parent folder location to store metadata. The project name will be added as a subfolder [Default: $SRAMETA:] :param metadata_folder: Specify an absolute folder location to store metadata. No subfolder will be added. Overrides value of --metadata-root [Default: Not used (--metadata-root is used by default)] :param just_metadata: If set, don't actually run downloads, just create metadata :param refresh_metadata: If set, re-download metadata even if it exists. :param config_template: Project config yaml file template. :param pipeline_samples: Specify one or more filepaths to SAMPLES pipeline interface yaml files. These will be added to the project config file to make it immediately compatible with looper. [Default: null] :param pipeline_project: Specify one or more filepaths to PROJECT pipeline interface yaml files. These will be added to the project config file to make it immediately compatible with looper. [Default: null] :param acc_anno: Produce annotation sheets for each accession. Project combined PEP for the whole project won't be produced. :param discard_soft: Create project without downloading soft files on the disc :param add_dotfile: Add .pep.yaml file that points .yaml PEP file :param disable_progressbar: Set true to disable progressbar

:param const_limit_project: Optional: Limit of the number of the constant sample characters that should not be in project yaml. [Default: 50] :param const_limit_discard: Optional: Limit of the number of the constant sample characters that should not be discarded [Default: 250] :param attr_limit_truncate: Optional: Limit of the number of sample characters. Any attribute with more than X characters will truncate to the first X, where X is a number of characters [Default: 500]

:param max_soft_size: Optional: Max size of soft file. Supported input formats : 12B, 12KB, 12MB, 12GB. [Default value: 1GB]

:param processed: Download processed da_soft_sizeta [Default: download raw data]. :param data_source: Specifies the source of data on the GEO record to retrieve processed data, which may be attached to the collective series entity, or to individual samples. Allowable values are: samples, series or both (all). Ignored unless 'processed' flag is set. [Default: samples] :param filter: Filter regex for processed filenames [Default: None].Ignored unless 'processed' flag is set. :param filter_size: Filter size for processed files that are stored as sample repository [Default: None]. Works only for sample data. Supported input formats : 12B, 12KB, 12MB, 12GB. Ignored unless 'processed' flag is set. :param geo_folder: Specify a location to store processed GEO files. Ignored unless 'processed' flag is set.[Default: $GEODATA:]

:param split_experiments: Split SRR runs into individual samples. By default, SRX experiments with multiple SRR Runs will have a single entry in the annotation table, with each run as a separate row in the subannotation table. This setting instead treats each run as a separate sample [Works with raw data] :param bam_folder: Optional: Specify folder of bam files. Geofetch will not download sra files when corresponding bam files already exist. [Default: $SRABAM:][Works with raw data] :param fq_folder: Optional: Specify folder of fastq files. Geofetch will not download sra files when corresponding fastq files already exist. [Default: $SRAFQ:][Works with raw data] :param use_key_subset: Use just the keys defined in this module when writing out metadata. [Works with raw data] :param sra_folder: Optional: Specify a location to store sra files [Default: $SRARAW:" + safe_echo("SRARAW") + ] :param bam_conversion: Optional: set True to convert bam files [Works with raw data] :param picard_path: Specify a path to the picard jar, if you want to convert fastq to bam [Default: $PICARD:" + safe_echo("PICARD") + "] [Works with raw data] :param add_convert_modifier: Add looper SRA convert modifier to config file.

:param skip: Skip some accessions. [Default: no skip]. :param opts: opts object [Optional] :param str | int max_prefetch_size: argmuent to prefetch command's --max-size option; for reference: https://github.com/ncbi/sra-tools/wiki/08.-prefetch-and-fasterq-dump#check-the-maximum-size-limit-of-the-prefetch-tool :param kwargs: other values

Source code in geofetch/geofetch.py

def __init__(
    self,
    name: str = "",
    metadata_root: str = "",
    metadata_folder: str = "",
    just_metadata: bool = False,
    refresh_metadata: bool = False,
    config_template: str = None,
    pipeline_samples: str = None,
    pipeline_project: str = None,
    skip: int = 0,
    acc_anno: bool = False,
    use_key_subset: bool = False,
    processed: bool = False,
    data_source: str = "samples",
    filter: str = None,
    filter_size: str = None,
    geo_folder: str = ".",
    split_experiments: bool = False,
    bam_folder: str = "",
    fq_folder: str = "",
    sra_folder: str = "",
    bam_conversion: bool = False,
    picard_path: str = "",
    input: str = None,
    const_limit_project: int = 50,
    const_limit_discard: int = 1000,
    attr_limit_truncate: int = 500,
    max_soft_size: str = "1GB",
    discard_soft: bool = False,
    add_dotfile: bool = False,
    disable_progressbar: bool = False,
    add_convert_modifier: bool = False,
    opts=None,
    max_prefetch_size=None,
    **kwargs,
):
    """
    Constructor

    :param input: GSEnumber or path to the input file
    :param name: Specify a project name. Defaults to GSE number or name of accessions file name
    :param metadata_root:  Specify a parent folder location to store metadata.
            The project name will be added as a subfolder [Default: $SRAMETA:]
    :param metadata_folder: Specify an absolute folder location to store metadata. No subfolder will be added.
            Overrides value of --metadata-root [Default: Not used (--metadata-root is used by default)]
    :param just_metadata: If set, don't actually run downloads, just create metadata
    :param refresh_metadata: If set, re-download metadata even if it exists.
    :param config_template: Project config yaml file template.
    :param pipeline_samples: Specify one or more filepaths to SAMPLES pipeline interface yaml files.
            These will be added to the project config file to make it immediately compatible with looper.
            [Default: null]
    :param pipeline_project: Specify one or more filepaths to PROJECT pipeline interface yaml files.
            These will be added to the project config file to make it immediately compatible with looper.
            [Default: null]
    :param acc_anno:  Produce annotation sheets for each accession.
            Project combined PEP for the whole project won't be produced.
    :param discard_soft: Create project without downloading soft files on the disc
    :param add_dotfile: Add .pep.yaml file that points .yaml PEP file
    :param disable_progressbar: Set true to disable progressbar

    :param const_limit_project: Optional: Limit of the number of the constant sample characters
            that should not be in project yaml. [Default: 50]
    :param const_limit_discard: Optional: Limit of the number of the constant sample characters
            that should not be discarded [Default: 250]
    :param attr_limit_truncate: Optional: Limit of the number of sample characters.
            Any attribute with more than X characters will truncate to the first X, where X is a number of characters
            [Default: 500]

    :param max_soft_size: Optional: Max size of soft file.
            Supported input formats : 12B, 12KB, 12MB, 12GB. [Default value: 1GB]

    :param processed: Download processed da_soft_sizeta [Default: download raw data].
    :param data_source: Specifies the source of data on the GEO record to retrieve processed data,
            which may be attached to the collective series entity, or to individual samples. Allowable values are:
            samples, series or both (all). Ignored unless 'processed' flag is set. [Default: samples]
    :param filter: Filter regex for processed filenames [Default: None].Ignored unless 'processed' flag is set.
    :param filter_size: Filter size for processed files that are stored as sample repository [Default: None].
            Works only for sample data. Supported input formats : 12B, 12KB, 12MB, 12GB.
            Ignored unless 'processed' flag is set.
    :param geo_folder: Specify a location to store processed GEO files.
            Ignored unless 'processed' flag is set.[Default: $GEODATA:]

    :param split_experiments: Split SRR runs into individual samples. By default, SRX experiments with multiple SRR
            Runs will have a single entry in the annotation table, with each run as a separate row in the
            subannotation table. This setting instead treats each run as a separate sample [Works with raw data]
    :param bam_folder: Optional: Specify folder of bam files. Geofetch will not download sra files when
            corresponding bam files already exist. [Default: $SRABAM:] [Works with raw data]
    :param fq_folder: Optional: Specify folder of fastq files. Geofetch will not download sra files when corresponding
            fastq files already exist. [Default: $SRAFQ:] [Works with raw data]
    :param use_key_subset: Use just the keys defined in this module when writing out metadata. [Works with raw data]
    :param sra_folder: Optional: Specify a location to store sra files
            [Default: $SRARAW:" + safe_echo("SRARAW") + ]
    :param bam_conversion: Optional: set True to convert bam files  [Works with raw data]
    :param picard_path:  Specify a path to the picard jar, if you want to convert fastq to bam
            [Default: $PICARD:" + safe_echo("PICARD") + "]  [Works with raw data]
    :param add_convert_modifier: Add looper SRA convert modifier to config file.

    :param skip: Skip some accessions. [Default: no skip].
    :param opts: opts object [Optional]
    :param str | int max_prefetch_size: argmuent to prefetch command's --max-size option;
        for reference: https://github.com/ncbi/sra-tools/wiki/08.-prefetch-and-fasterq-dump#check-the-maximum-size-limit-of-the-prefetch-tool
    :param kwargs: other values
    """

    global _LOGGER
    _LOGGER = (
        logmuse.logger_via_cli(opts)
        if opts is not None
        else logging.getLogger(__name__)
    )

    if name:
        self.project_name = name
    else:
        try:
            self.project_name = os.path.splitext(os.path.basename(input))[0]
        except TypeError:
            self.project_name = "project_name"

    if metadata_folder:
        self.metadata_expanded = expandpath(metadata_folder)
        if os.path.isabs(self.metadata_expanded):
            self.metadata_root_full = metadata_folder
        else:
            self.metadata_expanded = os.path.abspath(self.metadata_expanded)
            self.metadata_root_full = os.path.abspath(metadata_root)
        self.metadata_root_full = metadata_folder
    else:
        self.metadata_expanded = expandpath(metadata_root)
        if os.path.isabs(self.metadata_expanded):
            self.metadata_root_full = metadata_root
        else:
            self.metadata_expanded = os.path.abspath(self.metadata_expanded)
            self.metadata_root_full = os.path.abspath(metadata_root)

    self.just_metadata = just_metadata
    self.refresh_metadata = refresh_metadata
    self.config_template = config_template

    # if user specified a pipeline interface path for samples, add it into the project config
    if pipeline_samples and pipeline_samples != "null":
        self.file_pipeline_samples = pipeline_samples
        self.file_pipeline_samples = (
            f"pipeline_interfaces: {self.file_pipeline_samples}"
        )
    else:
        self.file_pipeline_samples = ""

    # if user specified a pipeline interface path, add it into the project config
    if pipeline_project:
        self.file_pipeline_project = (
            f"looper:\n    pipeline_interfaces: {pipeline_project}"
        )
    else:
        self.file_pipeline_project = ""

    self.skip = skip
    self.acc_anno = acc_anno
    self.use_key_subset = use_key_subset
    self.processed = processed
    self.supp_by = data_source

    if filter:
        self.filter_re = re.compile(filter.lower())
    else:
        self.filter_re = None

        # Postpend the project name as a subfolder (only for -m option)
        self.metadata_expanded = os.path.join(
            self.metadata_expanded, self.project_name
        )
        self.metadata_root_full = os.path.join(
            self.metadata_root_full, self.project_name
        )

    if filter_size is not None:
        try:
            self.filter_size = convert_size(filter_size.lower())
        except ValueError as message:
            _LOGGER.error(message)
            raise SystemExit()
    else:
        self.filter_size = filter_size

    self.geo_folder = geo_folder
    self.split_experiments = split_experiments
    self.bam_folder = bam_folder
    self.fq_folder = fq_folder
    self.sra_folder = sra_folder
    self.bam_conversion = bam_conversion
    self.picard_path = picard_path

    self.const_limit_project = const_limit_project
    self.const_limit_discard = const_limit_discard
    self.attr_limit_truncate = attr_limit_truncate
    self.max_soft_size = convert_size(max_soft_size.lower())

    self.discard_soft = discard_soft
    self.add_dotfile = add_dotfile
    self.disable_progressbar = disable_progressbar
    self.add_convert_modifier = add_convert_modifier
    _LOGGER.info(f"Metadata folder: {self.metadata_expanded}")

    # Some sanity checks before proceeding
    if bam_conversion and not just_metadata and not _which("samtools"):
        raise SystemExit("For SAM/BAM processing, samtools should be on PATH.")

    self.just_object = False
    self.max_prefetch_size = (
        "50g" if max_prefetch_size is None else max_prefetch_size
    )

fetch_all

fetch_all(input, name=None)

Main function driver/workflow Function that search, filters, downloads and save data and metadata from GEO and SRA :param input: GSE or input file with gse's :param name: Name of the project :return: NoReturn or peppy Project

Source code in geofetch/geofetch.py

def fetch_all(self, input: str, name: str = None) -> Union[NoReturn, peppy.Project]:
    """
    Main function driver/workflow
    Function that search, filters, downloads and save data and metadata from  GEO and SRA
    :param input: GSE or input file with gse's
    :param name: Name of the project
    :return: NoReturn or peppy Project
    """

    if name is not None:
        self.project_name = name
    else:
        try:
            self.project_name = os.path.splitext(os.path.basename(input))[0]
        except TypeError:
            self.project_name = input

    # check to make sure prefetch is callable
    if not self.just_metadata and not self.processed:
        if not is_prefetch_callable():
            raise SystemExit(
                "To download raw data, you must first install the sratoolkit, with prefetch in your PATH. "
                "Installation instruction: http://geofetch.databio.org/en/latest/install/"
            )

    acc_GSE_list = parse_accessions(
        input, self.metadata_expanded, self.just_metadata
    )
    if len(acc_GSE_list) == 1:
        self.disable_progressbar = True
    metadata_dict_combined = {}
    subannotation_dict_combined = {}

    processed_metadata_samples = []
    processed_metadata_series = []

    acc_GSE_keys = acc_GSE_list.keys()
    nkeys = len(acc_GSE_keys)
    ncount = 0
    for acc_GSE in track(
        acc_GSE_list.keys(),
        description="Processing... ",
        disable=self.disable_progressbar,
    ):
        try:
            ncount += 1
            if ncount <= self.skip:
                continue
            elif ncount == self.skip + 1:
                _LOGGER.info(f"Skipped {self.skip} accessions. Starting now.")

            if not self.just_object or not self.acc_anno:
                _LOGGER.info(
                    f"\033[38;5;200mProcessing accession {ncount} of {nkeys}: '{acc_GSE}'\033[0m"
                )

            if len(re.findall(GSE_PATTERN, acc_GSE)) != 1:
                _LOGGER.debug(len(re.findall(GSE_PATTERN, acc_GSE)))
                _LOGGER.warning(
                    "This does not appear to be a correctly formatted GSE accession! "
                    "Continue anyway..."
                )

            if len(acc_GSE_list[acc_GSE]) > 0:
                _LOGGER.info(
                    f"Limit to: {list(acc_GSE_list[acc_GSE])}"
                )  # a list of GSM#s

            # For each GSE acc, produce a series of metadata files
            file_gse = os.path.join(self.metadata_expanded, acc_GSE + "_GSE.soft")
            file_gsm = os.path.join(self.metadata_expanded, acc_GSE + "_GSM.soft")
            file_sra = os.path.join(self.metadata_expanded, acc_GSE + "_SRA.csv")

            if not os.path.isfile(file_gse) or self.refresh_metadata:
                file_gse_content = Accession(acc_GSE).fetch_metadata(
                    file_gse,
                    clean=self.discard_soft,
                    max_soft_size=self.max_soft_size,
                )
            else:
                _LOGGER.info(f"Found previous GSE file: {file_gse}")
                with open(file_gse, "r") as gse_file_obj:
                    file_gse_content = gse_file_obj.read().split("\n")
                file_gse_content = [
                    elem for elem in file_gse_content if len(elem) > 0
                ]

            file_gse_content_dict = gse_content_to_dict(file_gse_content)

            if not os.path.isfile(file_gsm) or self.refresh_metadata:
                file_gsm_content = Accession(acc_GSE).fetch_metadata(
                    file_gsm,
                    typename="GSM",
                    clean=self.discard_soft,
                    max_soft_size=self.max_soft_size,
                )
            else:
                _LOGGER.info(f"Found previous GSM file: {file_gsm}")
                with open(file_gsm, "r") as gsm_file_obj:
                    file_gsm_content = gsm_file_obj.read().split("\n")
                file_gsm_content = [
                    elem for elem in file_gsm_content if len(elem) > 0
                ]

            gsm_enter_dict = acc_GSE_list[acc_GSE]

            # download processed data
            if self.processed:
                (
                    meta_processed_samples,
                    meta_processed_series,
                ) = self.fetch_processed_one(
                    gse_file_content=file_gse_content,
                    gsm_file_content=file_gsm_content,
                    gsm_filter_list=gsm_enter_dict,
                )

                # download processed files:
                if not self.just_metadata:
                    self._download_processed_data(
                        acc_gse=acc_GSE,
                        meta_processed_samples=meta_processed_samples,
                        meta_processed_series=meta_processed_series,
                    )

                # generating PEPs for processed files:
                if self.acc_anno:
                    self._generate_processed_meta(
                        acc_GSE,
                        meta_processed_samples,
                        meta_processed_series,
                        gse_meta_dict=file_gse_content_dict,
                    )

                else:
                    # adding metadata from current experiment to the project
                    processed_metadata_samples.extend(meta_processed_samples)
                    processed_metadata_series.extend(meta_processed_series)

            else:
                # read gsm metadata
                gsm_metadata = self._read_gsm_metadata(
                    acc_GSE, acc_GSE_list, file_gsm_content
                )

                # download sra metadata
                srp_list_result = self._get_SRA_meta(
                    file_gse_content, gsm_metadata, file_sra
                )
                if not srp_list_result:
                    _LOGGER.info("No SRP data, continuing ....")
                    _LOGGER.warning("No raw pep will be created! ....")
                    # delete current acc if no raw data was found
                    # del metadata_dict[acc_GSE]
                    pass
                else:
                    _LOGGER.info("Parsing SRA file to download SRR records")
                gsm_multi_table, gsm_metadata, runs = self._process_sra_meta(
                    srp_list_result, gsm_enter_dict, gsm_metadata
                )

                # download raw data:
                if not self.just_metadata:
                    for run in runs:
                        # download raw data
                        _LOGGER.info(f"Getting SRR: {run}  in ({acc_GSE})")
                        self._download_raw_data(run)
                else:
                    _LOGGER.info("Dry run, no data will be downloaded")

                # save one project
                if self.acc_anno and nkeys > 1:
                    self._write_raw_annotation_new(
                        name=acc_GSE,
                        metadata_dict=gsm_metadata,
                        subannot_dict=gsm_multi_table,
                        gse_meta_dict=file_gse_content_dict,
                    )

                else:
                    metadata_dict_combined.update(gsm_metadata)
                    subannotation_dict_combined.update(gsm_multi_table)
        except Exception as e:
            _LOGGER.warning(f"Couldn't process {acc_GSE}: {e}", exc_info=True)
            continue

    _LOGGER.info(f"Finished processing {len(acc_GSE_list)} accession(s)")

    # Logging cleaning process:
    if self.discard_soft:
        _LOGGER.info("Cleaning soft files ...")
        clean_soft_files(self.metadata_root_full)

    #######################################################################################

    # saving PEPs for processed data
    if self.processed:
        if not self.acc_anno:
            return_value = self._generate_processed_meta(
                name=self.project_name,
                meta_processed_samples=processed_metadata_samples,
                meta_processed_series=processed_metadata_series,
                gse_meta_dict=(
                    file_gse_content_dict if len(acc_GSE_list.keys()) == 1 else None
                ),
            )
            if self.just_object:
                return return_value

    # saving PEPs for raw data
    else:
        return_value = self._write_raw_annotation_new(
            f"{self.project_name}_PEP",
            metadata_dict_combined,
            subannotation_dict_combined,
            gse_meta_dict=(
                file_gse_content_dict if len(acc_GSE_list.keys()) == 1 else None
            ),
        )
        if self.just_object:
            return return_value

fetch_processed_one

fetch_processed_one(gse_file_content, gsm_file_content, gsm_filter_list)

Fetche one processed GSE project and return its metadata :param gsm_file_content: gse soft file content :param gse_file_content: gsm soft file content :param gsm_filter_list: list of gsm that have to be downloaded :return: Tuple of project list of gsm samples and gse samples

Source code in geofetch/geofetch.py

def fetch_processed_one(
    self,
    gse_file_content: list,
    gsm_file_content: list,
    gsm_filter_list: dict,
) -> Tuple:
    """
    Fetche one processed GSE project and return its metadata
    :param gsm_file_content: gse soft file content
    :param gse_file_content: gsm soft file content
    :param gsm_filter_list: list of gsm that have to be downloaded
    :return: Tuple of project list of gsm samples and gse samples
    """
    (
        meta_processed_samples,
        meta_processed_series,
    ) = self._get_list_of_processed_files(gse_file_content, gsm_file_content)

    # taking into account list of GSM that is specified in the input file
    meta_processed_samples = _filter_gsm(meta_processed_samples, gsm_filter_list)

    # samples
    meta_processed_samples = self._expand_metadata_list(meta_processed_samples)

    # series
    meta_processed_series = self._expand_metadata_list(meta_processed_series)

    # convert column names to lowercase and underscore
    meta_processed_samples = _standardize_colnames(meta_processed_samples)
    meta_processed_series = _standardize_colnames(meta_processed_series)

    return meta_processed_samples, meta_processed_series

get_projects

get_projects(input, just_metadata=True, discard_soft=True)

Function for fetching projects from GEO|SRA and receiving peppy project :param input: GSE number, or path to file of GSE numbers :param just_metadata: process only metadata :param discard_soft: clean run, without downloading soft files :return: peppy project or list of project, if acc_anno is set.

Source code in geofetch/geofetch.py

def get_projects(
    self, input: str, just_metadata: bool = True, discard_soft: bool = True
) -> dict:
    """
    Function for fetching projects from GEO|SRA and receiving peppy project
    :param input: GSE number, or path to file of GSE numbers
    :param just_metadata: process only metadata
    :param discard_soft:  clean run, without downloading soft files
    :return: peppy project or list of project, if acc_anno is set.
    """
    self.just_metadata = just_metadata
    self.just_object = True
    self.discard_soft = discard_soft
    acc_GSE_list = parse_accessions(
        input, self.metadata_expanded, self.just_metadata
    )

    project_dict = {}

    # processed data:
    if self.processed:
        if self.acc_anno:
            self.disable_progressbar = True
            nkeys = len(acc_GSE_list.keys())
            ncount = 0
            self.acc_anno = False
            for acc_GSE in acc_GSE_list.keys():
                ncount += 1
                _LOGGER.info(
                    f"\033[38;5;200mProcessing accession {ncount} of {nkeys}: '{acc_GSE}'\033[0m"
                )
                project_dict.update(self.fetch_all(input=acc_GSE, name=acc_GSE))
        else:
            try:
                project_n = os.path.splitext(os.path.basename(input))[0]
            except TypeError:
                project_n = input
            project_dict.update(self.fetch_all(input=input, name=project_n))

    # raw data:
    else:
        # Not sure about below code...
        if self.acc_anno:
            self.disable_progressbar = True
            self.acc_anno = False
            nkeys = len(acc_GSE_list.keys())
            ncount = 0
            for acc_GSE in acc_GSE_list.keys():
                ncount += 1
                _LOGGER.info(
                    f"\033[38;5;200mProcessing accession {ncount} of {nkeys}: '{acc_GSE}'\033[0m"
                )
                project = self.fetch_all(input=acc_GSE)
                project_dict[acc_GSE + "_raw"] = project

        else:
            try:
                project_n = os.path.splitext(os.path.basename(input))[0]
            except TypeError:
                project_n = input
            ser_dict = self.fetch_all(input=input)
            project_dict[project_n + "_raw"] = ser_dict

    new_pr_dict = {}
    for pr_key in project_dict.keys():
        if project_dict[pr_key]:
            new_pr_dict[pr_key] = project_dict[pr_key]

    return new_pr_dict

Finder Class

Class for searching and finding GSE accessions:

Finder

Finder(filters=None, retmax=RETMAX)

Class for finding GSE accessions in special period of time. Additionally, user can add specific filters for the search, while initialization of the class

:param filters: filters that have to be added to the query. Filter Patterns can be found here: https://www.ncbi.nlm.nih.gov/books/NBK3837/#EntrezHelp.Using_the_Advanced_Search_Pag :param retmax: maximum number of retrieved accessions.