Python appdirs 模块，AppDirs() 实例源码

def initialize(unet=None, classifier=None):
    # Setup appdirs
    dirs = AppDirs("DeepROP", "QTIM", version=__version__)
    conf_dir = dirs.user_config_dir
    conf_file = join(conf_dir, 'config.yaml')

    if not isdir(conf_dir):
        makedirs(conf_dir)

    if not isfile(conf_file):
        config_dict = {'unet_directory': unet, 'classifier_directory': classifier}

        with open(conf_file, 'w') as f:
            yaml.dump(config_dict, f, default_flow_style=False)

    return yaml.load(open(conf_file, 'r')), conf_file

def init_requests_cache(refresh_cache=False):
    """
    Initializes a cache which the ``requests`` library will consult for
    responses, before making network requests.

    :param refresh_cache: Whether the cache should be cleared out
    """
    # Cache data from external sources; used in some checks
    dirs = AppDirs("stix2-validator", "OASIS")
    # Create cache dir if doesn't exist
    try:
        os.makedirs(dirs.user_cache_dir)
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise
    requests_cache.install_cache(
        cache_name=os.path.join(dirs.user_cache_dir, 'py{}cache'.format(
            sys.version_info[0])),
        expire_after=datetime.timedelta(weeks=1))

    if refresh_cache:
        clear_requests_cache()

def get_conda_test_dir():
    dirs = AppDirs('niceman')
    test_dir = os.path.join(dirs.user_cache_dir, 'conda_test')
    if os.path.exists(test_dir):
        return test_dir
    # Miniconda isn't installed, so install it
    if sys.platform.startswith('darwin'):
        miniconda_sh = "Miniconda2-latest-MacOSX-x86_64.sh"
    elif sys.platform.startswith('linux'):
        miniconda_sh = "Miniconda2-latest-Linux-x86_64.sh"
    else:
        raise ValueError("Conda test not supported with platform %s " %
                         sys.platform)
    call("mkdir -p " + test_dir + "; "
         "cd " + test_dir + "; "
         "curl -O https://repo.continuum.io/miniconda/" + miniconda_sh + "; "
         "bash -b " + miniconda_sh + " -b -p ./miniconda; "
         "./miniconda/bin/conda create -y -n mytest python=2.7; "
         "./miniconda/envs/mytest/bin/conda install -y xz -n mytest; "
         "./miniconda/envs/mytest/bin/pip install rpaths;",
         shell=True)
    return test_dir

def _init_dirs(self, config_dir, data_dir, log_dir):
    d = AppDirs()
    self.config_dir = join(AppDirs().site_config_dir,
                           CallerLookupKeys.APP_NAME) if config_dir is None else config_dir
    self.data_dir = join(d.site_data_dir, CallerLookupKeys.APP_NAME) if data_dir is None else data_dir
    self.log_dir = join(d.user_log_dir, CallerLookupKeys.APP_NAME) if log_dir is None else log_dir
    __make_dir(self, self.config_dir)
    __make_dir(self, self.data_dir)
    __make_dir(self, self.log_dir)

def get_data_dir():
    dirs = AppDirs("adblockradio", "quasoft")
    return dirs.user_data_dir

def appdir():
    """ Retorna el directorio donde deben estar los archivos de rafam_extract.
        Crea el directorio si no existe. """
    ad = appdirs.AppDirs(APP_NAME, APP_AUTHOR)
    config_dir = ad.user_config_dir

    if not os.path.isdir(config_dir):
        os.makedirs(config_dir)

    return config_dir

def get_data_path(dir_path):
    parts = dir_path.split('/')
    dirs = AppDirs('Electrify', 'Electrify')
    data_path = path_join(dirs.user_data_dir, *parts)

    if is_windows():
        data_path = data_path.replace(u'\\', u'/')

    if not os.path.exists(data_path):
        os.makedirs(data_path)

    return data_path

def __init__(self,
                 appname,
                 author=None,
                 version=None,
                 roaming=False,
                 create=True):
        self.app_dirs = AppDirs(appname, author, version, roaming)
        self.create = create
        super(_AppFS, self).__init__(
            getattr(self.app_dirs, self.app_dir),
            create=create
        )

def app_directories():
    """Generate dictionary with paths to the application folders."""
    user_dirs = appdirs.AppDirs("Weather_App", "")
    local_app_dir = user_dirs.user_data_dir
    data_dirs = {"Database": "", "Debug": ""}
    for sub_dir in data_dirs:
        path = os.path.join(local_app_dir, sub_dir)
        data_dirs[sub_dir] = path
    return data_dirs

def get_config_path():
    return AppDirs("telegram-send").user_config_dir + ".conf"

def main():
    """Main entry point"""
    # Build default paths for files.
    dirs = appdirs.AppDirs("hangupsbot", "hangupsbot")
    default_log_path = os.path.join(dirs.user_data_dir, "hangupsbot.log")
    default_cookies_path = os.path.join(dirs.user_data_dir, "cookies.json")
    default_config_path = os.path.join(dirs.user_data_dir, "config.json")
    default_memory_path = os.path.join(dirs.user_data_dir, "memory.json")

    # Configure argument parser
    parser = argparse.ArgumentParser(
        prog="hangupsbot",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("-d", "--debug", action="store_true",
                        help=_("log detailed debugging messages"))
    parser.add_argument("--log", default=default_log_path,
                        help=_("log file path"))
    parser.add_argument("--cookies", default=default_cookies_path,
                        help=_("cookie storage path"))
    parser.add_argument("--memory", default=default_memory_path,
                        help=_("memory storage path"))
    parser.add_argument("--config", default=default_config_path,
                        help=_("config storage path"))
    parser.add_argument("--retries", default=5, type=int,
                        help=_("Maximum disconnect / reconnect retries before "
                               "quitting"))
    parser.add_argument("--version", action="version",
                        version="%(prog)s {}".format(version.__version__),
                        help=_("show program\"s version number and exit"))
    args = parser.parse_args()


    # Create all necessary directories.
    for path in [args.log, args.cookies, args.config, args.memory]:
        directory = os.path.dirname(path)
        if directory and not os.path.isdir(directory):
            try:
                os.makedirs(directory)
            except OSError as err:
                sys.exit(_("Failed to create directory: %s"), err)

    # If there is no config file in user data directory, copy default one there
    if not os.path.isfile(args.config):
        try:
            shutil.copy(
                os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]),
                                             "config.json")),
                args.config)
        except (OSError, IOError) as err:
            sys.exit(_("Failed to copy default config file: %s"), err)

    configure_logging(args)

    # initialise the bot
    bot = HangupsBot(args.cookies, args.config, args.memory, args.retries)

    # start the bot
    bot.run()

def __init__(self, parent=None):
        """Initialize the config page's configuration group."""
        super(ConfigTomb, self).__init__(parent)

        config_directory = AppDirs('mausoleum', 'Mandeep').user_config_dir

        if not os.path.exists(config_directory):
            os.makedirs(config_directory)

        settings = pkg_resources.resource_filename(__name__, 'settings.toml')
        with open(settings) as default_config:
            default_config = default_config.read()

        self.user_config_file = os.path.join(config_directory, 'settings.toml')
        if not os.path.isfile(self.user_config_file):
            with open(self.user_config_file, 'a') as new_config_file:
                new_config_file.write(default_config)

        with open(self.user_config_file) as conffile:
            self.config = pytoml.load(conffile)

        config_box = QGroupBox("Configure Mausoleum")

        self.tomb_path_label = QLabel('Tomb Path', self)
        self.tomb_path_line = QLineEdit()
        self.tomb_path_line.setReadOnly(True)
        self.tomb_path_button = QPushButton('Select Path')

        self.tomb_path_button.clicked.connect(lambda: self.select_tomb_install_path(self.config))

        tomb_path_layout = QVBoxLayout()

        tomb_path_config_layout = QHBoxLayout()
        tomb_path_config_layout.addWidget(self.tomb_path_label)
        tomb_path_config_layout.addWidget(self.tomb_path_line)
        tomb_path_config_layout.addWidget(self.tomb_path_button)

        tomb_path_layout.addLayout(tomb_path_config_layout)

        config_box.setLayout(tomb_path_layout)

        main_layout = QVBoxLayout()
        main_layout.addWidget(config_box)
        main_layout.addStretch(1)
        self.setLayout(main_layout)

        self.set_tomb_path(self.config)

def __init__(self, controller):
        """Initialize Report class.

        Args:
            controller (Controller): controller object which will 
            store all the data required by each segment of the 
            application.

        :Attributes:
        :v_link (dict): Link to access variables in controller.
        :conn (sqlite3.Connection): Database object
        :cur (sqlite3.Cursor): Database cursor.
        :data_dirs (dict[str, str]): Data directories for the
            application.

        """
        self.controller = controller
        self.v_link = self.controller.app_data
        """:type : dict[str, any]"""

        # Create necessary application folders in 
        # C:\Users\User\AppData\Local
        user_dirs = appdirs.AppDirs("Weather_App", "")
        local_app_dir = user_dirs.user_data_dir
        self.data_dirs = {"Database": "",
                          "Debug": ""}
        for sub_dir in self.data_dirs:
            path = os.path.join(local_app_dir, sub_dir)
            self.data_dirs[sub_dir] = path
            os.makedirs(path, exist_ok=True)

        # Establish database connection.
        self.conn = sqlite3.connect(os.path.join(self.data_dirs["Database"],
                                                 "locations.db"))
        self.cur = self.conn.cursor()
        self.cur.execute("CREATE TABLE IF NOT EXISTS locations("
                         "Id INTEGER NOT NULL PRIMARY KEY , "
                         "Location TEXT NOT NULL UNIQUE, "
                         "Num_of_calls INTEGER NOT NULL DEFAULT 0, "
                         "Units TEXT)")
        # Read the last used units from the database and set in
        # controller.
        try:
            self.cur.execute("SELECT Units FROM locations WHERE Id=1")
            last_units = self.cur.fetchall()[0][0]
            if last_units != "":
                self.v_link["var_units"].set(last_units)
        # In case of the initial run with an empty database, default
        # units are metric.
        except IndexError:
            self.v_link["var_units"].set("metric")
        self.conn.commit()
        # Initial list of locations from previous use of the app for
        # loc_combobox ordered by amount of previous calls.
        self.combo_drop_menu()

def __init__(self, config, debug, packs):
        self.debug = debug
        if self.debug:
            print('using encoding {}'.format(sys.stdout.encoding))
        self.config_path = Path(config).resolve()
        self.packs = packs

        self.cache_dir = appdirs.AppDirs(
            appname='voodoo', appauthor='nikky').user_cache_dir

        # parse config
        config_dir = self.config_path.parent
        self.global_config = {}

        config_suffix = self.config_path.suffix
        if config_suffix == '.yaml':
            config_dir.mkdir(parents=True, exist_ok=True)
            output = io.StringIO()

            default_config = pkg_resources.resource_string(__name__, 'data/default.yaml').decode()
            output.write(default_config)

            output.write('\n# END DEFAULTS\n\n# BEGIN CONFIG\n\n')
            with open(self.config_path) as infile:
                output.write(infile.read())
            self.config_str = output.getvalue()
            output.close()

            self.global_config = yaml.safe_load(self.config_str)
            if self.debug:
                print(yaml.dump(self.global_config))
            self.config_path = config_dir
            temp_path = self.global_config.get('temp_path')
            if temp_path:
                temp_path = Path(self.config_path, temp_path)
                temp_path.mkdir(parents=True, exist_ok=True)
                temp_path = Path(temp_path, 'generated_config.yaml')
                with open(temp_path, 'w') as outfile:
                    outfile.write(self.config_str)
        else:
            print('requires yaml config file')
            exit(-1)

        # auth_file = args.auth or config.get('authentication', None)
        # auth = config.get('authentication', {})
        # if args.username_github and args.password_github:
        #     auth_github = {'username': args.username, 'password': args.password}
        #     auth['github'] = auth_github