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-21 15:56
📄 LICENSE Copyright (c) 2018, Tzu-ping Chung <uranusjr@gmail.com> Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.	751 B	2026-01-20 12:58
📄 __init__.py __all__ = [ "AbstractProvider", "AbstractResolver", "BaseReporter", "InconsistentCandidate", "RequirementsConflicted", "ResolutionError", "ResolutionImpossible", "ResolutionTooDeep", "Resolver", "__version__", ] __version__ = "1.2.1" from .providers import AbstractProvider from .reporters import BaseReporter from .resolvers import ( AbstractResolver, InconsistentCandidate, RequirementsConflicted, ResolutionError, ResolutionImpossible, ResolutionTooDeep, Resolver, )	541 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:56
📄 providers.py from __future__ import annotations from typing import ( TYPE_CHECKING, Generic, Iterable, Iterator, Mapping, Sequence, ) from .structs import CT, KT, RT, Matches, RequirementInformation if TYPE_CHECKING: from typing import Any, Protocol class Preference(Protocol): def __lt__(self, __other: Any) -> bool: ... class AbstractProvider(Generic[RT, CT, KT]): """Delegate class to provide the required interface for the resolver.""" def identify(self, requirement_or_candidate: RT \| CT) -> KT: """Given a requirement or candidate, return an identifier for it. This is used to identify, e.g. whether two requirements should have their specifier parts merged or a candidate matches a requirement via ``find_matches()``. """ raise NotImplementedError def get_preference( self, identifier: KT, resolutions: Mapping[KT, CT], candidates: Mapping[KT, Iterator[CT]], information: Mapping[KT, Iterator[RequirementInformation[RT, CT]]], backtrack_causes: Sequence[RequirementInformation[RT, CT]], ) -> Preference: """Produce a sort key for given requirement based on preference. As this is a sort key it will be called O(n) times per backtrack step, where n is the number of `identifier`s, if you have a check which is expensive in some sense. E.g. It needs to make O(n) checks per call or takes significant wall clock time, consider using `narrow_requirement_selection` to filter the `identifier`s, which is applied before this sort key is called. The preference is defined as "I think this requirement should be resolved first". The lower the return value is, the more preferred this group of arguments is. :param identifier: An identifier as returned by ``identify()``. This identifies the requirement being considered. :param resolutions: Mapping of candidates currently pinned by the resolver. Each key is an identifier, and the value is a candidate. The candidate may conflict with requirements from ``information``. :param candidates: Mapping of each dependency's possible candidates. Each value is an iterator of candidates. :param information: Mapping of requirement information of each package. Each value is an iterator of requirement information. :param backtrack_causes: Sequence of requirement information that are the requirements that caused the resolver to most recently backtrack. A requirement information instance is a named tuple with two members: * ``requirement`` specifies a requirement contributing to the current list of candidates. * ``parent`` specifies the candidate that provides (depended on) the requirement, or ``None`` to indicate a root requirement. The preference could depend on various issues, including (not necessarily in this order): * Is this package pinned in the current resolution result? * How relaxed is the requirement? Stricter ones should probably be worked on first? (I don't know, actually.) * How many possibilities are there to satisfy this requirement? Those with few left should likely be worked on first, I guess? * Are there any known conflicts for this requirement? We should probably work on those with the most known conflicts. A sortable value should be returned (this will be used as the ``key`` parameter of the built-in sorting function). The smaller the value is, the more preferred this requirement is (i.e. the sorting function is called with ``reverse=False``). """ raise NotImplementedError def find_matches( self, identifier: KT, requirements: Mapping[KT, Iterator[RT]], incompatibilities: Mapping[KT, Iterator[CT]], ) -> Matches[CT]: """Find all possible candidates that satisfy the given constraints. :param identifier: An identifier as returned by ``identify()``. All candidates returned by this method should produce the same identifier. :param requirements: A mapping of requirements that all returned candidates must satisfy. Each key is an identifier, and the value an iterator of requirements for that dependency. :param incompatibilities: A mapping of known incompatibile candidates of each dependency. Each key is an identifier, and the value an iterator of incompatibilities known to the resolver. All incompatibilities must be excluded from the return value. This should try to get candidates based on the requirements' types. For VCS, local, and archive requirements, the one-and-only match is returned, and for a "named" requirement, the index(es) should be consulted to find concrete candidates for this requirement. The return value should produce candidates ordered by preference; the most preferred candidate should come first. The return type may be one of the following: * A callable that returns an iterator that yields candidates. * An collection of candidates. * An iterable of candidates. This will be consumed immediately into a list of candidates. """ raise NotImplementedError def is_satisfied_by(self, requirement: RT, candidate: CT) -> bool: """Whether the given requirement can be satisfied by a candidate. The candidate is guaranteed to have been generated from the requirement. A boolean should be returned to indicate whether ``candidate`` is a viable solution to the requirement. """ raise NotImplementedError def get_dependencies(self, candidate: CT) -> Iterable[RT]: """Get dependencies of a candidate. This should return a collection of requirements that `candidate` specifies as its dependencies. """ raise NotImplementedError def narrow_requirement_selection( self, identifiers: Iterable[KT], resolutions: Mapping[KT, CT], candidates: Mapping[KT, Iterator[CT]], information: Mapping[KT, Iterator[RequirementInformation[RT, CT]]], backtrack_causes: Sequence[RequirementInformation[RT, CT]], ) -> Iterable[KT]: """ An optional method to narrow the selection of requirements being considered during resolution. This method is called O(1) time per backtrack step. :param identifiers: An iterable of `identifiers` as returned by ``identify()``. These identify all requirements currently being considered. :param resolutions: A mapping of candidates currently pinned by the resolver. Each key is an identifier, and the value is a candidate that may conflict with requirements from ``information``. :param candidates: A mapping of each dependency's possible candidates. Each value is an iterator of candidates. :param information: A mapping of requirement information for each package. Each value is an iterator of requirement information. :param backtrack_causes: A sequence of requirement information that are the requirements causing the resolver to most recently backtrack. A requirement information instance is a named tuple with two members: * ``requirement`` specifies a requirement contributing to the current list of candidates. * ``parent`` specifies the candidate that provides (is depended on for) the requirement, or ``None`` to indicate a root requirement. Must return a non-empty subset of `identifiers`, with the default implementation being to return `identifiers` unchanged. Those `identifiers` will then be passed to the sort key `get_preference` to pick the most prefered requirement to attempt to pin, unless `narrow_requirement_selection` returns only 1 requirement, in which case that will be used without calling the sort key `get_preference`. This method is designed to be used by the provider to optimize the dependency resolution, e.g. if a check cost is O(m) and it can be done against all identifiers at once then filtering the requirement selection here will cost O(m) but making it part of the sort key in `get_preference` will cost O(m*n), where n is the number of `identifiers`. Returns: Iterable[KT]: A non-empty subset of `identifiers`. """ return identifiers	8.71 KB	2026-01-20 12:58
📄 py.typed	0 B	2026-01-20 12:58
📄 reporters.py from __future__ import annotations from typing import TYPE_CHECKING, Collection, Generic from .structs import CT, KT, RT, RequirementInformation, State if TYPE_CHECKING: from .resolvers import Criterion class BaseReporter(Generic[RT, CT, KT]): """Delegate class to provide progress reporting for the resolver.""" def starting(self) -> None: """Called before the resolution actually starts.""" def starting_round(self, index: int) -> None: """Called before each round of resolution starts. The index is zero-based. """ def ending_round(self, index: int, state: State[RT, CT, KT]) -> None: """Called before each round of resolution ends. This is NOT called if the resolution ends at this round. Use `ending` if you want to report finalization. The index is zero-based. """ def ending(self, state: State[RT, CT, KT]) -> None: """Called before the resolution ends successfully.""" def adding_requirement(self, requirement: RT, parent: CT \| None) -> None: """Called when adding a new requirement into the resolve criteria. :param requirement: The additional requirement to be applied to filter the available candidaites. :param parent: The candidate that requires ``requirement`` as a dependency, or None if ``requirement`` is one of the root requirements passed in from ``Resolver.resolve()``. """ def resolving_conflicts( self, causes: Collection[RequirementInformation[RT, CT]] ) -> None: """Called when starting to attempt requirement conflict resolution. :param causes: The information on the collision that caused the backtracking. """ def rejecting_candidate(self, criterion: Criterion[RT, CT], candidate: CT) -> None: """Called when rejecting a candidate during backtracking.""" def pinning(self, candidate: CT) -> None: """Called when adding a candidate to the potential solution."""	1.99 KB	2026-01-20 12:58
📁 resolvers	-	2026-03-21 15:45
📄 structs.py from __future__ import annotations import itertools from collections import namedtuple from typing import ( TYPE_CHECKING, Callable, Generic, Iterable, Iterator, Mapping, NamedTuple, Sequence, TypeVar, Union, ) KT = TypeVar("KT") # Identifier. RT = TypeVar("RT") # Requirement. CT = TypeVar("CT") # Candidate. Matches = Union[Iterable[CT], Callable[[], Iterable[CT]]] if TYPE_CHECKING: from .resolvers.criterion import Criterion class RequirementInformation(NamedTuple, Generic[RT, CT]): requirement: RT parent: CT \| None class State(NamedTuple, Generic[RT, CT, KT]): """Resolution state in a round.""" mapping: dict[KT, CT] criteria: dict[KT, Criterion[RT, CT]] backtrack_causes: list[RequirementInformation[RT, CT]] else: RequirementInformation = namedtuple( "RequirementInformation", ["requirement", "parent"] ) State = namedtuple("State", ["mapping", "criteria", "backtrack_causes"]) class DirectedGraph(Generic[KT]): """A graph structure with directed edges.""" def __init__(self) -> None: self._vertices: set[KT] = set() self._forwards: dict[KT, set[KT]] = {} # <key> -> Set[<key>] self._backwards: dict[KT, set[KT]] = {} # <key> -> Set[<key>] def __iter__(self) -> Iterator[KT]: return iter(self._vertices) def __len__(self) -> int: return len(self._vertices) def __contains__(self, key: KT) -> bool: return key in self._vertices def copy(self) -> DirectedGraph[KT]: """Return a shallow copy of this graph.""" other = type(self)() other._vertices = set(self._vertices) other._forwards = {k: set(v) for k, v in self._forwards.items()} other._backwards = {k: set(v) for k, v in self._backwards.items()} return other def add(self, key: KT) -> None: """Add a new vertex to the graph.""" if key in self._vertices: raise ValueError("vertex exists") self._vertices.add(key) self._forwards[key] = set() self._backwards[key] = set() def remove(self, key: KT) -> None: """Remove a vertex from the graph, disconnecting all edges from/to it.""" self._vertices.remove(key) for f in self._forwards.pop(key): self._backwards[f].remove(key) for t in self._backwards.pop(key): self._forwards[t].remove(key) def connected(self, f: KT, t: KT) -> bool: return f in self._backwards[t] and t in self._forwards[f] def connect(self, f: KT, t: KT) -> None: """Connect two existing vertices. Nothing happens if the vertices are already connected. """ if t not in self._vertices: raise KeyError(t) self._forwards[f].add(t) self._backwards[t].add(f) def iter_edges(self) -> Iterator[tuple[KT, KT]]: for f, children in self._forwards.items(): for t in children: yield f, t def iter_children(self, key: KT) -> Iterator[KT]: return iter(self._forwards[key]) def iter_parents(self, key: KT) -> Iterator[KT]: return iter(self._backwards[key]) class IteratorMapping(Mapping[KT, Iterator[CT]], Generic[RT, CT, KT]): def __init__( self, mapping: Mapping[KT, RT], accessor: Callable[[RT], Iterable[CT]], appends: Mapping[KT, Iterable[CT]] \| None = None, ) -> None: self._mapping = mapping self._accessor = accessor self._appends: Mapping[KT, Iterable[CT]] = appends or {} def __repr__(self) -> str: return "IteratorMapping({!r}, {!r}, {!r})".format( self._mapping, self._accessor, self._appends, ) def __bool__(self) -> bool: return bool(self._mapping or self._appends) def __contains__(self, key: object) -> bool: return key in self._mapping or key in self._appends def __getitem__(self, k: KT) -> Iterator[CT]: try: v = self._mapping[k] except KeyError: return iter(self._appends[k]) return itertools.chain(self._accessor(v), self._appends.get(k, ())) def __iter__(self) -> Iterator[KT]: more = (k for k in self._appends if k not in self._mapping) return itertools.chain(self._mapping, more) def __len__(self) -> int: more = sum(1 for k in self._appends if k not in self._mapping) return len(self._mapping) + more class _FactoryIterableView(Iterable[RT]): """Wrap an iterator factory returned by `find_matches()`. Calling `iter()` on this class would invoke the underlying iterator factory, making it a "collection with ordering" that can be iterated through multiple times, but lacks random access methods presented in built-in Python sequence types. """ def __init__(self, factory: Callable[[], Iterable[RT]]) -> None: self._factory = factory self._iterable: Iterable[RT] \| None = None def __repr__(self) -> str: return f"{type(self).__name__}({list(self)})" def __bool__(self) -> bool: try: next(iter(self)) except StopIteration: return False return True def __iter__(self) -> Iterator[RT]: iterable = self._factory() if self._iterable is None else self._iterable self._iterable, current = itertools.tee(iterable) return current class _SequenceIterableView(Iterable[RT]): """Wrap an iterable returned by find_matches(). This is essentially just a proxy to the underlying sequence that provides the same interface as `_FactoryIterableView`. """ def __init__(self, sequence: Sequence[RT]): self._sequence = sequence def __repr__(self) -> str: return f"{type(self).__name__}({self._sequence})" def __bool__(self) -> bool: return bool(self._sequence) def __iter__(self) -> Iterator[RT]: return iter(self._sequence) def build_iter_view(matches: Matches[CT]) -> Iterable[CT]: """Build an iterable view from the value returned by `find_matches()`.""" if callable(matches): return _FactoryIterableView(matches) if not isinstance(matches, Sequence): matches = list(matches) return _SequenceIterableView(matches) IterableView = Iterable	6.27 KB	2026-01-20 12:58

Terminal