Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-27 02:38
📄 __init__.py from requirements_detector.detect import ( # from_setup_py, CouldNotParseRequirements, RequirementsNotFound, find_requirements, from_pyproject_toml, from_requirements_blob, from_requirements_dir, from_requirements_txt, from_setup_py, )	269 B	2026-01-20 12:58
📄 __main__.py from .run import run if __name__ == "__main__": run()	59 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 detect.py import re from pathlib import Path from typing import List, Union import toml from .exceptions import CouldNotParseRequirements, RequirementsNotFound from .handle_setup import from_setup_py from .poetry_semver import parse_constraint from .requirement import DetectedRequirement __all__ = [ "find_requirements", "from_requirements_txt", "from_requirements_dir", "from_requirements_blob", "from_pyproject_toml", "from_setup_py", "RequirementsNotFound", "CouldNotParseRequirements", ] _PIP_OPTIONS = ( "-i", "--index-url", "--extra-index-url", "--no-index", "-f", "--find-links", "-r", ) P = Union[str, Path] def find_requirements(path: P) -> List[DetectedRequirement]: """ This method tries to determine the requirements of a particular project by inspecting the possible places that they could be defined. It will attempt, in order: 1) to parse setup.py in the root for an install_requires value 2) to read a requirements.txt file or a requirements.pip in the root 3) to read all .txt files in a folder called 'requirements' in the root 4) to read files matching "requirements.txt" and "reqs.txt" in the root, excluding any starting or ending with 'test' If one of these succeeds, then a list of pkg_resources.Requirement's will be returned. If none can be found, then a RequirementsNotFound will be raised """ requirements = [] if isinstance(path, str): path = Path(path) setup_py = path / "setup.py" if setup_py.exists() and setup_py.is_file(): try: requirements = from_setup_py(setup_py) requirements.sort() return requirements except CouldNotParseRequirements: pass poetry_toml = path / "pyproject.toml" if poetry_toml.exists() and poetry_toml.is_file(): try: requirements = from_pyproject_toml(poetry_toml) if len(requirements) > 0: requirements.sort() return requirements except CouldNotParseRequirements: pass for reqfile_name in ("requirements.txt", "requirements.pip"): reqfile = path / reqfile_name if reqfile.exists and reqfile.is_file(): try: requirements += from_requirements_txt(reqfile) except CouldNotParseRequirements as e: pass requirements_dir = path / "requirements" if requirements_dir.exists() and requirements_dir.is_dir(): from_dir = from_requirements_dir(requirements_dir) if from_dir is not None: requirements += from_dir from_blob = from_requirements_blob(path) if from_blob is not None: requirements += from_blob requirements = list(set(requirements)) if len(requirements) > 0: requirements.sort() return requirements raise RequirementsNotFound def from_pyproject_toml(toml_file: P) -> List[DetectedRequirement]: requirements = [] if isinstance(toml_file, str): toml_file = Path(toml_file) parsed = toml.load(toml_file) poetry_section = parsed.get("tool", {}).get("poetry", {}) dependencies = poetry_section.get("dependencies", {}) dependencies.update(poetry_section.get("dev-dependencies", {})) for name, spec in dependencies.items(): if name.lower() == "python": continue if isinstance(spec, dict): if "version" in spec: spec = spec["version"] else: req = DetectedRequirement.parse(f"{name}", toml_file) if req is not None: requirements.append(req) continue parsed_spec = str(parse_constraint(spec)) if "," not in parsed_spec and "<" not in parsed_spec and ">" not in parsed_spec and "=" not in parsed_spec: parsed_spec = f"=={parsed_spec}" req = DetectedRequirement.parse(f"{name}{parsed_spec}", toml_file) if req is not None: requirements.append(req) return requirements def from_requirements_txt(requirements_file: P) -> List[DetectedRequirement]: # see http://www.pip-installer.org/en/latest/logic.html requirements = [] if isinstance(requirements_file, str): requirements_file = Path(requirements_file) with requirements_file.open() as f: for req in f.readlines(): if req.strip() == "": # empty line continue if req.strip().startswith("#"): # this is a comment continue if req.strip().split()[0] in _PIP_OPTIONS: # this is a pip option continue detected = DetectedRequirement.parse(req, requirements_file) if detected is None: continue requirements.append(detected) return requirements def from_requirements_dir(path: P) -> List[DetectedRequirement]: requirements = [] if isinstance(path, str): path = Path(path) for entry in path.iterdir(): if not entry.is_file(): continue if entry.name.endswith(".txt") or entry.name.endswith(".pip"): requirements += from_requirements_txt(entry) return list(set(requirements)) def from_requirements_blob(path: P) -> List[DetectedRequirement]: requirements = [] if isinstance(path, str): path = Path(path) for entry in path.iterdir(): if not entry.is_file(): continue m = re.match(r"^(\w)req(uirement)?s(\w)\.txt$", entry.name) if m is None: continue if m.group(1).startswith("test") or m.group(3).endswith("test"): continue requirements += from_requirements_txt(entry) return requirements	5.74 KB	2026-01-20 12:58
📄 exceptions.py class RequirementsNotFound(Exception): pass class CouldNotParseRequirements(Exception): pass	103 B	2026-01-20 12:58
📄 formatters.py import sys from typing import List from .requirement import DetectedRequirement def requirements_file(requirements_list: List[DetectedRequirement]) -> None: for requirement in requirements_list: sys.stdout.write(requirement.pip_format()) sys.stdout.write("\n") FORMATTERS = {"requirements_file": requirements_file}	340 B	2026-01-20 12:58
📄 handle_setup.py from pathlib import Path from typing import Union from astroid import MANAGER, AstroidBuildingException, AstroidSyntaxError from astroid.builder import AstroidBuilder from astroid.nodes import Assign, AssignName, Call, Const, Keyword, List, Name, Tuple from .exceptions import CouldNotParseRequirements from .requirement import DetectedRequirement class SetupWalker: def __init__(self, ast): self._ast = ast self._setup_call = None self._top_level_assigns = {} self.walk() def walk(self, node=None): top = node is None node = node or self._ast # test to see if this is a call to setup() if isinstance(node, Call): for child_node in node.get_children(): if isinstance(child_node, Name) and child_node.name == "setup": # TODO: what if this isn't actually the distutils setup? self._setup_call = node for child_node in node.get_children(): if top and isinstance(child_node, Assign): for target in child_node.targets: if isinstance(target, AssignName): self._top_level_assigns[target.name] = child_node.value self.walk(child_node) def _get_list_value(self, list_node): values = [] for child_node in list_node.get_children(): if not isinstance(child_node, Const): # we can't handle anything fancy, only constant values raise CouldNotParseRequirements values.append(child_node.value) return values def get_requires(self): # first, if we have a call to setup, then we can see what its "install_requires" argument is if not self._setup_call: raise CouldNotParseRequirements found_requirements = [] for child_node in self._setup_call.get_children(): if not isinstance(child_node, Keyword): # do we want to try to handle positional arguments? continue if child_node.arg not in ("install_requires", "requires"): continue if isinstance(child_node.value, (List, Tuple)): # joy! this is a simple list or tuple of requirements # this is a Keyword -> List or Keyword -> Tuple found_requirements += self._get_list_value(child_node.value) continue if isinstance(child_node.value, Name): # otherwise, it's referencing a value defined elsewhere # this will be a Keyword -> Name try: reqs = self._top_level_assigns[child_node.value.name] except KeyError: raise CouldNotParseRequirements else: if isinstance(reqs, (List, Tuple)): found_requirements += self._get_list_value(reqs) continue # otherwise it's something funky and we can't handle it raise CouldNotParseRequirements # if we've fallen off the bottom with nothing in our list of requirements, # we simply didn't find anything useful if len(found_requirements) > 0: return found_requirements raise CouldNotParseRequirements def from_setup_py(setup_file: Union[str, Path]): if isinstance(setup_file, str): setup_file = Path(setup_file) try: ast = AstroidBuilder(MANAGER).string_build(setup_file.open().read()) except (SyntaxError, AstroidBuildingException, AstroidSyntaxError): # if the setup file is broken, we can't do much about that... raise CouldNotParseRequirements walker = SetupWalker(ast) requirements = [] for req in walker.get_requires(): requirements.append(DetectedRequirement.parse(req, setup_file)) return [requirement for requirement in requirements if requirement is not None]	3.91 KB	2026-01-20 12:58
📁 poetry_semver	-	2026-03-21 15:45
📄 requirement.py """ This module represents the various types of requirement that can be specified for a project. It is somewhat redundant to re-implement here as we could use `pip.req.InstallRequirement`, but that would require depending on pip which is not easy to do since it will usually be installed by the user at a specific version. Additionally, the pip implementation has a lot of extra features that we don't need - we don't expect relative file paths to exist, for example. Note that the parsing here is also intentionally more lenient - it is not our job to validate the requirements list. """ import os import re from pathlib import Path from typing import Optional from urllib import parse from packaging.requirements import Requirement def _is_filepath(req): # this is (probably) a file return os.path.sep in req or req.startswith(".") def _parse_egg_name(url_fragment): """ >>> _parse_egg_name('egg=fish&cake=lala') fish >>> _parse_egg_name('something_spurious') None """ if "=" not in url_fragment: return None parts = parse.parse_qs(url_fragment) if "egg" not in parts: return None return parts["egg"][0] # taking the first value mimics pip's behaviour def _strip_fragment(urlparts): new_urlparts = ( urlparts.scheme, urlparts.netloc, urlparts.path, urlparts.params, urlparts.query, None, ) return parse.urlunparse(new_urlparts) class DetectedRequirement: def __init__( self, name: str = None, url: str = None, requirement: Requirement = None, location_defined: Path = None ): if requirement is not None: self.name = requirement.name self.requirement = requirement self.version_specs = [(s.operator, s.version) for s in requirement.specifier] self.url = None else: self.name = name self.version_specs = [] self.url = url self.requirement = None self.location_defined = location_defined def _format_specs(self) -> str: return ",".join(["%s%s" % (comp, version) for comp, version in self.version_specs]) def pip_format(self) -> str: if self.url: if self.name: return "%s#egg=%s" % (self.url, self.name) return self.url if self.name: if self.version_specs: return "%s%s" % (self.name, self._format_specs()) return self.name raise ValueError(f"Cannot convert {self} to pip format, no name or URL") def __str__(self): rep = self.name or "Unknown" if self.version_specs: specs = ",".join(["%s%s" % (comp, ver) for comp, ver in self.version_specs]) rep = "%s%s" % (rep, specs) if self.url: rep = "%s (%s)" % (rep, self.url) return rep def __hash__(self): return hash(str(self.name) + str(self.url) + str(self.version_specs)) def __repr__(self): return "<DetectedRequirement:%s>" % str(self) def __eq__(self, other): return self.name == other.name and self.url == other.url and self.version_specs == other.version_specs def __gt__(self, other): return (self.name or "") > (other.name or "") @staticmethod def parse(line, location_defined: Path = None) -> Optional["DetectedRequirement"]: # the options for a Pip requirements file are: # # 1) <dependency_name> # 2) <dependency_name><version_spec> # 3) <vcs_url>(#egg=<dependency_name>)? # 4) <url_to_archive>(#egg=<dependency_name>)? # 5) <path_to_dir> # 6) (-e\|--editable) <path_to_dir>(#egg=<dependency_name)? # 7) (-e\|--editable) <vcs_url>#egg=<dependency_name> line = line.strip() if line.startswith("--hash=sha256:"): # skip multi-line shas, produced by poetry export return None # We need to match whitespace + # because url based requirements specify # egg_name after a '#' comment_pos = re.search(r"\s#", line) if comment_pos: line = line[: comment_pos.start()] # strip the editable flag line = re.sub("^(-e\|--editable) ", "", line) # remove the python version stuff from poetry files line = line.split(";")[0] url = parse.urlparse(line) # if it is a VCS URL, then we want to strip off the protocol as urlparse # might not handle it correctly vcs_scheme = None if "+" in url.scheme or url.scheme in ("git",): if url.scheme == "git": vcs_scheme = "git+git" else: vcs_scheme = url.scheme url = parse.urlparse(re.sub(r"^%s://" % re.escape(url.scheme), "", line)) if vcs_scheme is None and url.scheme == "" and not _is_filepath(line): # if we are here, it is a simple dependency try: req = Requirement(line) except ValueError: # this happens if the line is invalid return None else: return DetectedRequirement(requirement=req, location_defined=location_defined) # otherwise, this is some kind of URL name = _parse_egg_name(url.fragment) url = _strip_fragment(url) if vcs_scheme: url = "%s://%s" % (vcs_scheme, url) return DetectedRequirement(name=name, url=url, location_defined=location_defined)	5.42 KB	2026-01-20 12:58
📄 run.py import os import sys from pathlib import Path from typing import NoReturn from . import find_requirements from .exceptions import RequirementsNotFound from .formatters import FORMATTERS def _die(message) -> NoReturn: sys.stderr.write("%s\n" % message) sys.exit(1) def run() -> NoReturn: if len(sys.argv) > 1: path = Path(sys.argv[1]) else: path = Path.cwd() if not path.exists(): _die("%s does not exist" % path) if not path.is_dir(): _die("%s is not a directory" % path) try: requirements = find_requirements(path) except RequirementsNotFound: _die("Unable to find requirements at %s" % path) format_name = "requirements_file" # TODO: other output formats such as JSON FORMATTERS[format_name](requirements) sys.exit(0) if __name__ == "__main__": run()	861 B	2026-01-20 12:58

Terminal