ULTRA [ www.resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-427.42.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Nov 1 14:58:02 EDT 2024 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.90

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / thread-self / root / opt / alt / python37 / lib / python3.7 / site-packages / prospector /

Home Upload Mass Deface Mass Delete Back Connect Notify

finder.py

# -*- coding: utf-8 -*-
import os

from prospector.pathutils import is_virtualenv

class SingleFiles(object):

"""
    When prospector is run in 'single file mode' - that is,
    the argument is a python module rather than a directory -
    then we'll use this object instead of the FoundFiles to
    give all the functionality needed to check a single file.
    """

# The 'even if ignored' parameters are kept to show this is meant
    # to be API compatible with FoundFiles, but pylint will warn, so
    # let's disable
    # pylint:disable=unused-argument
    def __init__(self, files, rootpath):
        self.files = files
        self.rootpath = rootpath

def _check(self, checkpath, abspath=True):
        if abspath:
            checkpath = os.path.abspath(checkpath)
            return checkpath in map(os.path.abspath, self.files)
        return checkpath in self.files

def check_module(self, filepath, abspath=True, even_if_ignored=False):
        return self._check(filepath, abspath)

def check_package(self, filepath, abspath=True, even_if_ignored=False):
        return self._check(filepath, abspath)

def check_file(self, filepath, abspath=True, even_if_ignored=False):
        return self._check(filepath, abspath)

def iter_file_paths(self, abspath=True, include_ignored=False):
        for filepath in self.files:
            yield os.path.abspath(filepath) if abspath else filepath

def iter_package_paths(self, abspath=True, include_ignored=False):
        for filepath in self.files:
            yield os.path.abspath(filepath) if abspath else filepath

def iter_directory_paths(self, abspath=True, include_ignored=False):
        for filepath in self.files:
            filepath = os.path.dirname(filepath)
            yield os.path.abspath(filepath) if abspath else filepath

def iter_module_paths(self, abspath=True, include_ignored=False):
        for filepath in self.files:
            yield os.path.abspath(filepath) if abspath else filepath

def to_absolute_path(self, path):
        return os.path.abspath(os.path.join(self.rootpath, path))

def get_minimal_syspath(self, absolute_paths=True):
        paths = list(set(map(os.path.dirname, self.files)))
        if absolute_paths:
            paths = list(map(os.path.abspath, paths))
        return [self.rootpath] + paths

class FoundFiles(object):
    def __init__(self, rootpath, files, modules, packages, directories, ignores):
        self.rootpath = rootpath
        self._files = files
        self._modules = modules
        self._packages = packages
        self._directories = directories
        self._ignores = ignores

def _check(self, filepath, pathlist, abspath=True, even_if_ignored=False):
        path = os.path.relpath(filepath, self.rootpath) if abspath else filepath
        for checkpath, ignored in pathlist:
            if path == checkpath:
                if ignored and not even_if_ignored:
                    break
                return True
        return False

def check_module(self, filepath, abspath=True, even_if_ignored=False):
        return self._check(filepath, self._modules, abspath, even_if_ignored)

def check_package(self, filepath, abspath=True, even_if_ignored=False):
        return self._check(filepath, self._packages, abspath, even_if_ignored)

def check_file(self, filepath, abspath=True, even_if_ignored=False):
        return self._check(filepath, self._files, abspath, even_if_ignored)

def _iter_paths(self, pathlist, abspath=True, include_ignored=False):
        for path, ignored in pathlist:
            if ignored and not include_ignored:
                continue
            if abspath:
                path = self.to_absolute_path(path)
            yield path

def iter_file_paths(self, abspath=True, include_ignored=False):
        return self._iter_paths(self._files, abspath, include_ignored)

def iter_package_paths(self, abspath=True, include_ignored=False):
        return self._iter_paths(self._packages, abspath, include_ignored)

def iter_directory_paths(self, abspath=True, include_ignored=False):
        return self._iter_paths(self._directories, abspath, include_ignored)

def iter_module_paths(self, abspath=True, include_ignored=False):
        return self._iter_paths(self._modules, abspath, include_ignored)

def to_absolute_path(self, path):
        return os.path.abspath(os.path.join(self.rootpath, path))

def get_minimal_syspath(self, absolute_paths=True):
        """
        Provide a list of directories that, when added to sys.path, would enable
        any of the discovered python modules to be found
        """
        # firstly, gather a list of the minimum path to each package
        package_list = set()
        packages = [p[0] for p in self._packages if not p[1]]
        for package in sorted(packages, key=len):
            parent = os.path.split(package)[0]
            if parent not in packages and parent not in package_list:
                package_list.add(parent)

# now add the directory containing any modules who are not in packages
        module_list = []
        modules = [m[0] for m in self._modules if not m[1]]
        for module in modules:
            dirname = os.path.dirname(module)
            if dirname not in packages:
                module_list.append(dirname)

full_list = sorted(set(module_list) | package_list | {self.rootpath}, key=len)
        if absolute_paths:
            full_list = [os.path.join(self.rootpath, p).rstrip(os.path.sep) for p in full_list]
        return full_list

def _find_paths(ignore, curpath, rootpath):
    files, modules, packages, directories = [], [], [], []

for filename in os.listdir(curpath):
        fullpath = os.path.join(curpath, filename)
        try:
            relpath = os.path.relpath(fullpath, rootpath)
        except ValueError:
            # relpath breaks on long paths in Windows
            continue

if filename.startswith('.') and os.path.isdir(fullpath):
            continue

if os.path.islink(fullpath):
            continue

ignored = any([m.search(relpath) for m in ignore])

if os.path.isdir(fullpath):

# is it probably a virtualenvironment?
            if is_virtualenv(fullpath) or '.tox' in fullpath:
                continue

# this is a directory
            directories.append((relpath, ignored))

# is it also a package?
            initpy = os.path.join(fullpath, '__init__.py')
            if os.path.exists(initpy) and os.path.isfile(initpy):
                packages.append((relpath, ignored))

# do the same for this directory
            recurse = _find_paths(ignore, os.path.join(curpath, filename), rootpath)
            files += recurse[0]
            modules += recurse[1]
            packages += recurse[2]
            directories += recurse[3]

else:
            # this is a file, is it a python module?
            if fullpath.endswith('.py'):
                modules.append((relpath, ignored))
            files.append((relpath, ignored))

return files, modules, packages, directories

def find_python(ignores, paths, explicit_file_mode, workdir=''):
    """
    Returns a FoundFiles class containing a list of files, packages, directories,
    where files are simply all python (.py) files, packages are directories
    containing an `__init__.py` file, and directories is a list of all directories.
    All paths are relative to the dirpath argument.
    """
    if explicit_file_mode:
        return SingleFiles(paths, workdir or os.getcwd())
    else:
        assert len(paths) == 1
        files, modules, directories, packages = _find_paths(ignores, paths[0], workdir)
        return FoundFiles(workdir, files, modules, directories, packages, ignores)

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2024-07-05 06:21:05
..	dir	-	root/linksafe	drwxr-xr-x	2024-07-05 06:24:07
__pycache__	dir	-	root/linksafe	drwxr-xr-x	2024-07-05 06:21:05
config	dir	-	root/linksafe	drwxr-xr-x	2024-07-05 06:21:05
formatters	dir	-	root/linksafe	drwxr-xr-x	2024-07-05 06:21:05
profiles	dir	-	root/linksafe	drwxr-xr-x	2024-07-05 06:21:05
tools	dir	-	root/linksafe	drwxr-xr-x	2024-07-05 06:21:05
__init__.py	application/x-empty	0 B	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
__main__.py	text/plain	119 B	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
__pkginfo__.py	text/plain	104 B	root/linksafe	-rw-r--r--	2019-07-26 06:04:11
autodetect.py	text/x-script.python	2.85 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
blender.py	text/x-script.python	4.29 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
blender_combinations.yaml	text/plain	5.25 KB	root/linksafe	-rw-r--r--	2019-07-26 06:04:11
encoding.py	text/x-script.python	1.4 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
exceptions.py	text/x-script.python	640 B	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
finder.py	text/x-script.python	7.68 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
message.py	text/x-script.python	3.29 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
pathutils.py	text/x-script.python	983 B	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
postfilter.py	text/x-script.python	2.09 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
run.py	text/x-script.python	6.72 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07
suppression.py	text/x-script.python	4.12 KB	root/linksafe	-rw-r--r--	2019-05-21 02:23:07