Das deutsche Python-Forum

Code: Alles auswählen

class BAR():
    def __init__(self):
        self.foo1 = FOO()

Code: Alles auswählen

class Security:
    """Main class for security."""

    @staticmethod
    def get_password(count, hard=False):
        """Creates a password.

        :param count: int
        :param hard: bool -> std False
            Creates a password of the desired length. By default all
            ascii letters are used (upper and lower case) and numbers.
            If hard is on <True>, special characters are also used.
        :return: str
        """

        if hard:
            x = string.ascii_letters + string.digits + string.punctuation
        else:
            x = string.ascii_letters + string.digits

        return ''.join(secrets.choice(x) for _ in range(count))

Code: Alles auswählen

class FileBase:
    def __init__(self, filepath):
        self._filepath = filepath
        self._user_extensions = []
        self._excluded = []
        self._files = []

    def get_files_from_directory(self):
        path = os.path.join(self._filepath, '**')
        self._files.append(glob.glob(path, recursive=True))
        return self._files

    def get_specified_files_from_directory(self):
        for root, directories, files in os.walk(self._filepath):
            for directory in directories:
                dir_path = os.path.join(root, directory)
                print(dir_path)
                for file in files:
                    file_path = os.path.join(root, directory, file)
                    print(file_path)
                    for excluded in self._excluded:
                        if excluded not in file_path:
                            self._files.append(file_path)

        print(self._files)


    def set_excluded_list(self, excluded):
        """Terms or paths that are not used in the search.

        :param excluded: <list|tuple> <list|tuple>. Delivery as list.
        :return: None
        """

        if type(excluded) == list or type(excluded) == tuple:
            self._excluded.extend(excluded)

    def set_file_extensions_list(self, extensions):
        """Sets the list of file extensions.

        :param extensions: <list|tuple>. Delivery as list.
        :return: None
        """

        if type(extensions) == list or type(extensions) == tuple:
            self._user_extensions.extend(extensions)

Code: Alles auswählen

def get_root_password(self):
        pw_len = self._inputs('root password length (1 - 100): ')
        return Security.get_password(pw_len)

Code: Alles auswählen

def create_password(length, hard=False):
    """Create a password.

    :param length: int
    :param hard: bool -> std False
        Creates a password of the desired length. By default all
        ascii letters are used (upper and lower case) and numbers.
        If hard is on <True>, special characters are also used.
    :return: str
    """
    characters = string.ascii_letters + string.digits
    if hard:
        characters += string.punctuation
    return ''.join(random.choice(characters) for _ in range(length))


def get_paths(path):
    return glob.glob(os.path.join(path, '**'), recursive=True)


def get_filenames(path, excluded=()):
    result = list()
    for root, _, filenames in os.walk(path):
        for filename in filenames:
            full_path = os.path.join(root, filename)
            if not any(part in full_path for part in excluded):
                result.append(full_path)
    return result