arg2p 0.19.0__py3-none-any.whl

arg2p/__init__.py

@@ -0,0 +1,63 @@
+"""
+Arg2P from Python: structured argumentation in Prolog (ASPIC+, ABA, abstract frameworks, ...), the library of the JVM
+run through JPype, on the Java runtime the package bundles.
+
+    >>> from arg2p import Arg2p
+    >>> Arg2p.of("r1 : [] => a.\nr2 : [] => -a.\nsup(r1, r2).").answer("a").in_statements
+    ['a']
+"""
+
+from .arg2p import Answer, Arg2p, Arg2pError, Builder, Causality, Solution, Solutions
+from .flags import (
+    ConflictModel,
+    Flags,
+    GraphBuilder,
+    GraphExtension,
+    GraphLanguage,
+    OrderingComparator,
+    OrderingPrinciple,
+    Profile,
+    Semantics,
+    StatementLabelling,
+)
+from .model import Argument, Attack, Graph, LabelledArgument, Support
+from .parallel import EvaluationResponse, LocalCluster, Response, ThreadedCluster
+from .values import Struct, Value, Var
+
+try:
+    from ._version import __version__
+except ImportError:  # a package built without Gradle
+    __version__ = "0.0.0"
+
+__all__ = [
+    "Answer",
+    "Arg2p",
+    "Arg2pError",
+    "Argument",
+    "Attack",
+    "Builder",
+    "Causality",
+    "ConflictModel",
+    "EvaluationResponse",
+    "Flags",
+    "Graph",
+    "GraphBuilder",
+    "GraphExtension",
+    "GraphLanguage",
+    "LabelledArgument",
+    "LocalCluster",
+    "OrderingComparator",
+    "OrderingPrinciple",
+    "Profile",
+    "Response",
+    "Semantics",
+    "Solution",
+    "Solutions",
+    "StatementLabelling",
+    "Struct",
+    "Support",
+    "ThreadedCluster",
+    "Value",
+    "Var",
+    "__version__",
+]

arg2p/__main__.py

@@ -0,0 +1,49 @@
+"""The labels of the statements of a theory, from the command line: python -m arg2p theory.pl [-q query] ..."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Optional
+
+from .arg2p import Arg2p, Arg2pError
+from .flags import Flags, Profile, Semantics
+from .values import text
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="arg2p", description="Evaluates a theory of arg2p.")
+    parser.add_argument("theory", help="the file of the theory (- for the standard input)")
+    parser.add_argument("-q", "--query", action="append", help="a statement to evaluate (all of them by default)")
+    parser.add_argument("-p", "--profile", choices=[it.value for it in Profile], help="the profile of the theory")
+    parser.add_argument("-s", "--semantics", choices=[it.value for it in Semantics], help="the semantics")
+    arguments = parser.parse_args(argv)
+    theory = sys.stdin.read() if arguments.theory == "-" else open(arguments.theory, encoding="utf-8").read()
+    flags = Flags.defaults()
+    if arguments.profile:
+        flags.graph_build_mode(Profile(arguments.profile))
+    if arguments.semantics:
+        flags.argument_labelling_mode(Semantics(arguments.semantics))
+    try:
+        arg2p = Arg2p.of(theory, flags)
+        if arguments.query:
+            for query in arguments.query:
+                answer = arg2p.answer(query)
+                print(
+                    f"{query}: in {text(answer.in_statements)}, out {text(answer.out_statements)}, "
+                    f"und {text(answer.und_statements)}"
+                )
+        else:
+            for index, graph in enumerate(arg2p.graphs()):
+                if index:
+                    print()
+                for label in ("in", "out", "und"):
+                    print(f"{label}: {', '.join(sorted(graph.conclusions(label)))}")
+    except Arg2pError as error:
+        print(f"arg2p: {error}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

arg2p/_jvm.py

@@ -0,0 +1,145 @@
+"""The JVM running arg2p: started once, at the first use, with the jars of the package, on the Java runtime it
+bundles (that of the system, for a package without one)."""
+
+from __future__ import annotations
+
+import glob
+import os
+import sys
+import threading
+from typing import Any, Callable, TypeVar
+
+import jpype
+
+T = TypeVar("T")
+
+_lock = threading.Lock()
+
+#: The jars of the package, copied there by ``./gradlew :python:pythonJars``
+JARS = os.path.join(os.path.dirname(__file__), "jars")
+
+#: The Java runtime the package bundles, made there by ``./gradlew :python:pythonRuntime``
+RUNTIME = os.path.join(os.path.dirname(__file__), "jre")
+
+#: The stack of the threads of the JVM: resolution goes deep (the tests of arg2p run with the same)
+STACK = os.environ.get("ARG2P_STACK", "512m")
+
+
+def classpath() -> list[str]:
+    """The jars of arg2p: those of ``ARG2P_CLASSPATH`` if set, those of the package otherwise."""
+    stated = os.environ.get("ARG2P_CLASSPATH")
+    if stated:
+        return stated.split(os.pathsep)
+    jars = sorted(glob.glob(os.path.join(JARS, "*.jar")))
+    if not jars:
+        raise RuntimeError(
+            "No jar of arg2p in " + JARS + ": copy them with ./gradlew :python:pythonJars, "
+            "or set ARG2P_CLASSPATH"
+        )
+    return jars
+
+
+def jvm_path() -> str:
+    """
+    The library of the JVM: that of ``ARG2P_JVM`` if set, of the runtime the package bundles if it does, of the system
+    otherwise (JAVA_HOME, or where JPype finds one).
+    """
+    stated = os.environ.get("ARG2P_JVM")
+    if stated:
+        return stated
+    library = {"win32": ("bin", "server", "jvm.dll"), "darwin": ("lib", "server", "libjvm.dylib")}.get(
+        sys.platform, ("lib", "server", "libjvm.so")
+    )
+    bundled = os.path.join(RUNTIME, *library)
+    return bundled if os.path.exists(bundled) else jpype.getDefaultJVMPath()
+
+
+def start() -> None:
+    """Starts the JVM, unless it runs already (started by another library: the jars of arg2p must be on its path)."""
+    with _lock:
+        if not jpype.isJVMStarted():
+            jpype.startJVM(
+                jvm_path(), f"-Xss{STACK}", "-Dslf4j.internal.verbosity=ERROR", classpath=classpath(), convertStrings=True
+            )
+
+
+def jclass(name: str) -> Any:
+    """The Java class [name], the JVM started."""
+    start()
+    return jpype.JClass(name)
+
+
+@jpype.JImplements("java.lang.Runnable", deferred=True)
+class _Task:
+    def __init__(self, function: Callable[[], Any]) -> None:
+        self.function = function
+        self.value: Any = None
+        self.error: BaseException | None = None
+
+    @jpype.JOverride
+    def run(self) -> None:
+        try:
+            self.value = self.function()
+        except BaseException as error:  # noqa: BLE001 - raised again by the caller
+            self.error = error
+
+
+@jpype.JImplements("java.util.concurrent.ThreadFactory", deferred=True)
+class _Threads:
+    @jpype.JOverride
+    def newThread(self, runnable: Any) -> Any:
+        # daemons, not to hold the JVM when Python exits; their stack is the one of -Xss (see STACK)
+        thread = jpype.JClass("java.lang.Thread")(runnable, _THREAD)
+        thread.setDaemon(True)
+        return thread
+
+
+_THREAD = "arg2p"
+_pool: Any = None
+
+
+def _threads() -> Any:
+    """The threads running arg2p, made as calls need them and kept for the next ones (a minute idle)."""
+    global _pool
+    with _lock:
+        if _pool is None:
+            _pool = jpype.JClass("java.util.concurrent.Executors").newCachedThreadPool(_Threads())
+    return _pool
+
+
+def run(function: Callable[[], T]) -> T:
+    """The result of [function], run on a thread of the JVM, whose stack resolution needs (see STACK)."""
+    start()
+    if str(jpype.JClass("java.lang.Thread").currentThread().getName()) == _THREAD:
+        return function()  # already on one
+    task = _Task(function)
+    _threads().submit(task).get()
+    if task.error is not None:
+        raise task.error
+    return task.value
+
+
+@jpype.JImplements("kotlin.jvm.functions.Function1", deferred=True)
+class _Function:
+    def __init__(self, function: Callable[[Any], Any]) -> None:
+        self.function = function
+
+    @jpype.JOverride
+    def invoke(self, value: Any) -> Any:
+        return self.function(value)
+
+
+def function1(function: Callable[[Any], Any]) -> Any:
+    """[function] as a Kotlin function of one argument returning Unit."""
+    unit = jclass("kotlin.Unit").INSTANCE
+
+    def invoke(value: Any) -> Any:
+        function(value)
+        return unit
+
+    return _Function(invoke)
+
+
+def jarray(name: str, values: list[Any]) -> Any:
+    """A Java array of the class [name], of [values]."""
+    return jpype.JArray(jclass(name))(values)

arg2p/_version.py

@@ -0,0 +1,2 @@
+# Generated by the build (./gradlew :python:pythonVersion): the version of arg2p
+__version__ = "0.19.0"

arg2p/arg2p.py

@@ -0,0 +1,271 @@
+"""A solver of arg2p: its answers, graphs and solutions, and the causality tests on its theory."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Iterator, Optional
+
+import jpype
+
+from . import _jvm
+from .flags import Flags
+from .model import Graph, graph_from_jvm
+from .values import Value, from_jvm
+
+_API = "it.unibo.tuprolog.argumentation"
+
+
+class Arg2pError(Exception):
+    """An evaluation halted by an error: a theory its profile refuses, a goal that cannot be parsed, ..."""
+
+
+def call(function: Callable[[], Any]) -> Any:
+    """The result of [function], run on a thread of the JVM, an exception of arg2p raised as an Arg2pError."""
+
+    def guarded() -> Any:
+        try:
+            return function()
+        except jpype.JException as error:
+            if error.getClass().getName() == f"{_API}.Arg2pException":
+                raise Arg2pError(str(error.getMessage())) from None
+            raise
+
+    return _jvm.run(guarded)
+
+
+@dataclass(frozen=True)
+class Answer:
+    """The statements for a query labelled in, out and und (see Arg2p.answer)."""
+
+    in_statements: list[Value] = field(default_factory=list)
+    out_statements: list[Value] = field(default_factory=list)
+    und_statements: list[Value] = field(default_factory=list)
+    # the answer of the library of the JVM, for label
+    _answer: Any = field(default=None, compare=False, repr=False)
+
+    def label(self, statement: str) -> Optional[str]:
+        """The label of [statement], Prolog text: in, out or und, None for a statement the query did not label."""
+        if self._answer is None:
+            raise ValueError("Not the answer of a solver")
+        label = call(lambda: self._answer.label(statement))
+        return None if label is None else str(label)
+
+
+class Solution:
+    """A solution of a goal: yes, no or halt (an error), with the values a yes solution binds to its variables."""
+
+    def __init__(self, solution: Any) -> None:
+        self._solution = solution
+
+    @property
+    def is_yes(self) -> bool:
+        return bool(self._solution.isYes())
+
+    @property
+    def is_no(self) -> bool:
+        return bool(self._solution.isNo())
+
+    @property
+    def is_halt(self) -> bool:
+        return bool(self._solution.isHalt())
+
+    @property
+    def query(self) -> str:
+        """The goal, as a yes solution solves it (its variables bound), otherwise as it was asked, as Prolog text."""
+        return str(self._solution.getQuery())
+
+    @property
+    def error(self) -> Optional[str]:
+        """The error of a halt solution."""
+        error = self._solution.getError()
+        return None if error is None else str(error)
+
+    @property
+    def variables(self) -> list[str]:
+        """The variables of the goal a yes solution binds."""
+        return [str(name) for name in self._solution.getVariables()]
+
+    @property
+    def bindings(self) -> dict[str, Value]:
+        """The values a yes solution binds to the variables of the goal, by their names."""
+        return {str(entry.getKey()): from_jvm(entry.getValue()) for entry in self._solution.getBindings().entrySet()}
+
+    def value(self, name: str) -> Optional[Value]:
+        """The value a yes solution binds to the variable of the goal named [name]."""
+        value = self._solution.value(name)
+        return None if value is None else from_jvm(value)
+
+    def text(self, name: str) -> Optional[str]:
+        """The value a yes solution binds to the variable of the goal named [name], as Prolog text."""
+        written = self._solution.text(name)
+        return None if written is None else str(written)
+
+    def __repr__(self) -> str:
+        return str(self._solution.toString())
+
+
+class Solutions:
+    """The solutions of a goal, computed one at a time as they are asked for: with has_next and next, or iterated."""
+
+    def __init__(self, solutions: Any) -> None:
+        self._solutions = solutions
+
+    def has_next(self) -> bool:
+        return bool(_jvm.run(self._solutions.hasNext))
+
+    def next(self) -> Solution:
+        return Solution(_jvm.run(self._solutions.next))
+
+    def to_list(self, limit: Optional[int] = None) -> list[Solution]:
+        """The solutions left, at most [limit] of them."""
+        return [Solution(it) for it in _jvm.run(lambda: self._solutions.toList(2**31 - 1 if limit is None else limit))]
+
+    def __iter__(self) -> Iterator[Solution]:
+        return self
+
+    def __next__(self) -> Solution:
+        # the next solution, if there is one, in a single call
+        found = _jvm.run(lambda: self._solutions.next() if self._solutions.hasNext() else None)
+        if found is None:
+            raise StopIteration
+        return Solution(found)
+
+
+class Causality:
+    """
+    Whether a statement of the theory of a solver causes another, on the grounded labelling of the theory and of its
+    interventions: the NESS test, as published (Pisano, Prakken, Sartor, Liepina; ICAIL 2025) and revised, and the
+    but-for test. The statements are Prolog text; an intervention is a list of statements.
+    """
+
+    def __init__(self, causality: Any) -> None:
+        self._causality = causality
+
+    def ness(self, cause: str, effect: str) -> Optional[Value]:
+        """Whether [cause] is a NESS cause of [effect] (the revised condition): the intervention, None if it is not."""
+        return _optional(call(lambda: self._causality.ness(cause, effect)))
+
+    def ness_original(self, cause: str, effect: str) -> Optional[Value]:
+        """Whether [cause] is a NESS cause of [effect] as published: the intervention, None if it is not."""
+        return _optional(call(lambda: self._causality.nessOriginal(cause, effect)))
+
+    def ness_intervention(self, intervention: str, effect: str) -> bool:
+        """Whether [intervention], a list of statements, meets the revised NESS condition for [effect]."""
+        return bool(call(lambda: self._causality.nessIntervention(intervention, effect)))
+
+    def ness_original_intervention(self, intervention: str, effect: str) -> bool:
+        """Whether [intervention], a list of statements, meets the NESS condition for [effect] as published."""
+        return bool(call(lambda: self._causality.nessOriginalIntervention(intervention, effect)))
+
+    def but_for(self, cause: str, effect: str) -> bool:
+        """Whether [cause] is a but-for cause of [effect]."""
+        return bool(call(lambda: self._causality.butFor(cause, effect)))
+
+
+def _optional(value: Any) -> Optional[Value]:
+    return None if value is None else from_jvm(value)
+
+
+class Arg2p:
+    """
+    A solver of arg2p for a theory, as Prolog text, with its flags: it answers queries (answer), gives the graph of
+    each labelling (graphs), solves Prolog goals (solve) and tests causality (causality).
+
+        >>> Arg2p.of("r1 : [] => a.\\nr2 : [] => -a.\\nsup(r1, r2).").answer("a").in_statements
+        ['a']
+
+    The context of the solver keeps a branch for every stage of a resolution, numbered from 0: active_branch is the
+    last one, graph_at the graph of any of them, and context_facts what a branch stores.
+    """
+
+    def __init__(self, arg2p: Any) -> None:
+        self._arg2p = arg2p
+        self.causality = Causality(arg2p.getCausality())
+
+    @staticmethod
+    def of(theory: str = "", flags: Optional[Flags] = None) -> Arg2p:
+        """A solver of arg2p for [theory], Prolog text, with [flags] (Flags.defaults() otherwise)."""
+        return Arg2p.builder().theory(theory).flags(flags or Flags.defaults()).build()
+
+    @staticmethod
+    def builder() -> Builder:
+        """A solver of arg2p, as it is described."""
+        return Builder()
+
+    @staticmethod
+    def version() -> str:
+        """The version of arg2p, the released one for a release."""
+        return str(_jvm.jclass(f"{_API}.Arg2p").version())
+
+    @property
+    def theory(self) -> str:
+        """The theory, as Prolog text."""
+        return str(self._arg2p.getTheory())
+
+    def answer(self, query: str) -> Answer:
+        """The statements for [query], Prolog text, labelled in, out and und (raises Arg2pError if it halts)."""
+        answer = call(lambda: self._arg2p.answer(query))
+        return Answer(
+            [from_jvm(it) for it in answer.getInStatements()],
+            [from_jvm(it) for it in answer.getOutStatements()],
+            [from_jvm(it) for it in answer.getUndStatements()],
+            answer,
+        )
+
+    def graphs(self) -> list[Graph]:
+        """The graph of each labelling of the theory: several for a semantics with several (preferred, stable, ...)."""
+        return call(lambda: [graph_from_jvm(graph) for graph in self._arg2p.graphs()])
+
+    def graph(self) -> Graph:
+        """The graph of the last resolution: the one of its last stage."""
+        return call(lambda: graph_from_jvm(self._arg2p.graph()))
+
+    def graph_at(self, branch: int) -> Graph:
+        """The graph of the context branch [branch]."""
+        return call(lambda: graph_from_jvm(self._arg2p.graphAt(branch)))
+
+    @property
+    def active_branch(self) -> int:
+        """The context branch of the last stage of the last resolution."""
+        return int(call(self._arg2p.getActiveBranch))
+
+    def solve(self, goal: str) -> Solutions:
+        """The solutions of [goal], Prolog text, computed one at a time as they are asked for."""
+        return Solutions(call(lambda: self._arg2p.solve(goal)))
+
+    def context_facts(self, branch: int, goal: str) -> Solutions:
+        """What the context branch [branch] stores matching [goal], Prolog text: the solutions of context_check/2."""
+        return Solutions(call(lambda: self._arg2p.contextFacts(branch, goal)))
+
+    def add(self, theory: str) -> None:
+        """Adds the clauses of [theory], Prolog text, to the theory."""
+        call(lambda: self._arg2p.add(theory))
+
+    def load(self, theory: str) -> None:
+        """Replaces the theory with [theory], Prolog text."""
+        call(lambda: self._arg2p.load(theory))
+
+
+class Builder:
+    """A solver of arg2p, as it is described: its theory, its flags, and where what it prints goes."""
+
+    def __init__(self) -> None:
+        self._builder = _jvm.jclass(f"{_API}.Arg2p").builder()
+
+    def theory(self, theory: str) -> Builder:
+        """The theory, as Prolog text."""
+        self._builder.theory(theory)
+        return self
+
+    def flags(self, flags: Flags) -> Builder:
+        """The flags (Flags.defaults() otherwise)."""
+        self._builder.flags(flags.jvm())
+        return self
+
+    def output(self, consumer: Callable[[str], Any]) -> Builder:
+        """The function receiving what the solver prints (the standard output otherwise)."""
+        self._builder.output(_jvm.function1(lambda printed: consumer(str(printed))))
+        return self
+
+    def build(self) -> Arg2p:
+        return Arg2p(call(self._builder.build))

arg2p/flags.py

@@ -0,0 +1,224 @@
+"""The flags of a solver (see the flags reference of arg2p), and the values they take."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from . import _jvm
+
+_API = "it.unibo.tuprolog.argumentation"
+
+
+class _FlagValue(Enum):
+    """A value of a flag: [value] is the atom stating it in a theory."""
+
+    def jvm(self) -> Any:
+        """The value of the library of the JVM."""
+        return getattr(_jvm.jclass(f"{_API}.{type(self).__name__}"), self.name)
+
+
+class Profile(_FlagValue):
+    """The profile of a theory (graphBuildMode): the flags its definition needs, preset."""
+
+    FREE = "free"
+    ASPIC_PLUS = "aspic_plus"
+    ASPIC = "aspic"
+    ASPIC_DEFEASIBLE = "aspic_defeasible"
+    META = "meta"
+    ABA = "aba"
+    ABA_PLUS = "aba_plus"
+    ABSTRACT = "abstract"
+
+
+class Semantics(_FlagValue):
+    """The semantics of the argument labelling (argumentLabellingMode)."""
+
+    CONFLICT_FREE = "conflictfree"
+    ADMISSIBLE = "admissible"
+    STRONGLY_ADMISSIBLE = "stronglyadmissible"
+    GROUNDED = "grounded"
+    COMPLETE = "complete"
+    PREFERRED = "preferred"
+    SEMI_STABLE = "semistable"
+    STABLE = "stable"
+    IDEAL = "ideal"
+    EAGER = "eager"
+    NAIVE = "naive"
+    STAGE = "stage"
+    CF2 = "cf2"
+    STAGE2 = "stage2"
+    BP_GROUNDED = "bp_grounded"
+    BP_GROUNDED_PARTIAL = "bp_grounded_partial"
+    BP_GROUNDED_COMPLETE = "bp_grounded_complete"
+
+
+class StatementLabelling(_FlagValue):
+    """The labelling of the statements from that of the arguments (statementLabellingMode)."""
+
+    STATEMENT = "statement"
+    STATEMENT_PASS_THROUGH = "statement_pass_through"
+    STATEMENT_BINARY = "statement_binary"
+
+
+class OrderingPrinciple(_FlagValue):
+    """The ordering principle of the preferences (orderingPrinciple)."""
+
+    LAST = "last"
+    WEAKEST = "weakest"
+
+
+class OrderingComparator(_FlagValue):
+    """The comparator of the sets of rules or premises (orderingComparator)."""
+
+    ELITIST = "elitist"
+    DEMOCRAT = "democrat"
+    NORMAL = "normal"
+
+
+class GraphExtension(_FlagValue):
+    """An extension of the graph (graphExtension)."""
+
+    REBUT_RESTRICTION = "rebutRestriction"
+    BP = "bp"
+    STANDARD_PREF = "standardPref"
+    DEFEASIBLE_PREF = "defeasiblePref"
+    DEFEASIBLE_ALL_PREF = "defeasibleAllPref"
+    ABA_PREF = "abaPref"
+
+
+class GraphLanguage(_FlagValue):
+    """A language extending the one of arg2p (graphLanguage)."""
+
+    ASPIC_LANGUAGE = "aspicLanguage"
+    ABA_LANGUAGE = "abaLanguage"
+    DEFEASIBLE_LANGUAGE = "defeasibleLanguage"
+
+
+class GraphBuilder(_FlagValue):
+    """The module building the graph (graphBuilder): from the rules, or from the arguments and attacks."""
+
+    RULE_GRAPH = "ruleGraph"
+    ABSTRACT_GRAPH = "abstractGraph"
+
+
+class ConflictModel(_FlagValue):
+    """The conflicts beyond those a theory declares (conflictModel)."""
+
+    BUILTIN = "builtin"
+    DECLARED = "declared"
+
+
+def _array(cls: type, values: tuple) -> Any:
+    return _jvm.jarray(f"{_API}.{cls.__name__}", [value.jvm() for value in values])
+
+
+class Flags:
+    """
+    The flags of a solver, as the facts stating them: defaults() (those of arg2p), none() (only those the theory
+    states), or parse(text). A flag set replaces what the flags stated for it; the theory may state flags as well,
+    which override these. The profile of the theory (graph_build_mode) presets the flags its definition needs.
+    """
+
+    def __init__(self, flags: Any) -> None:
+        self._flags = flags
+
+    @staticmethod
+    def defaults() -> Flags:
+        """The flags of arg2p by default."""
+        return Flags(_jvm.jclass(f"{_API}.Flags").defaults())
+
+    @staticmethod
+    def none() -> Flags:
+        """No flags: the solver has only those the theory states, the others are the defaults of their modules."""
+        return Flags(_jvm.jclass(f"{_API}.Flags").none())
+
+    @staticmethod
+    def parse(text: str) -> Flags:
+        """The flags stated by the facts of [text], Prolog text (argumentLabellingMode(preferred). queryMode.)."""
+        return Flags(_jvm.jclass(f"{_API}.Flags").parse(text))
+
+    def jvm(self) -> Any:
+        """The flags of the library of the JVM."""
+        return self._flags
+
+    def graph_build_mode(self, profile: Profile) -> Flags:
+        """The profile of the theory."""
+        return self._set(self._flags.graphBuildMode(profile.jvm()))
+
+    def argument_labelling_mode(self, semantics: Semantics) -> Flags:
+        """The semantics of the argument labelling."""
+        return self._set(self._flags.argumentLabellingMode(semantics.jvm()))
+
+    def statement_labelling_mode(self, labelling: StatementLabelling) -> Flags:
+        """The labelling of the statements."""
+        return self._set(self._flags.statementLabellingMode(labelling.jvm()))
+
+    def ordering_principle(self, principle: OrderingPrinciple) -> Flags:
+        """The ordering principle of the preferences."""
+        return self._set(self._flags.orderingPrinciple(principle.jvm()))
+
+    def ordering_comparator(self, comparator: OrderingComparator) -> Flags:
+        """The comparator of the preferences."""
+        return self._set(self._flags.orderingComparator(comparator.jvm()))
+
+    def graph_extensions(self, *extensions: GraphExtension) -> Flags:
+        """The extensions of the graph: none for no extension."""
+        return self._set(self._flags.graphExtensions(_array(GraphExtension, extensions)))
+
+    def graph_language(self, *languages: GraphLanguage) -> Flags:
+        """The languages extending the one of arg2p: none for no language."""
+        return self._set(self._flags.graphLanguage(_array(GraphLanguage, languages)))
+
+    def graph_builder(self, builder: GraphBuilder) -> Flags:
+        """The module building the graph."""
+        return self._set(self._flags.graphBuilder(builder.jvm()))
+
+    def conflict_model(self, model: ConflictModel) -> Flags:
+        """The conflicts beyond those the theory declares."""
+        return self._set(self._flags.conflictModel(model.jvm()))
+
+    def modules_path(self, path: str) -> Flags:
+        """Where the modules loaded by name are looked for."""
+        return self._set(self._flags.modulesPath(path))
+
+    def query_mode(self, on: bool) -> Flags:
+        """Whether the graph is built on the arguments the query depends on alone."""
+        return self._set(self._flags.queryMode(on))
+
+    def auto_transposition(self, on: bool) -> Flags:
+        """Whether the strict rules are transposed."""
+        return self._set(self._flags.autoTransposition(on))
+
+    def prolog_strict_compatibility(self, on: bool) -> Flags:
+        """Whether the theory is read as strict Prolog (no rules of arg2p)."""
+        return self._set(self._flags.prologStrictCompatibility(on))
+
+    def meta_conflicts(self, on: bool) -> Flags:
+        """Whether the conflicts are arguments as well."""
+        return self._set(self._flags.metaConflicts(on))
+
+    def meta_rules(self, on: bool) -> Flags:
+        """Whether the rules are arguments as well."""
+        return self._set(self._flags.metaRules(on))
+
+    def debug(self, on: bool) -> Flags:
+        """Whether the modules print their debug output."""
+        return self._set(self._flags.debug(on))
+
+    def _set(self, flags: Any) -> Flags:
+        self._flags = flags
+        return self
+
+    def __str__(self) -> str:
+        """The flags as the facts stating them, Prolog text."""
+        return str(self._flags.toString())
+
+    def __repr__(self) -> str:
+        return f"Flags({str(self)!r})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Flags) and bool(self._flags.equals(other._flags))
+
+    def __hash__(self) -> int:
+        return int(self._flags.hashCode())

arg2p/model.py

@@ -0,0 +1,102 @@
+"""The argumentation graph of a labelling, as plain data: its arguments, their labels, attacks and supports."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+@dataclass(frozen=True)
+class Argument:
+    """
+    An argument: its rules, its top rule (none for a premise) and its conclusion, with the arguments it is built on
+    (supports), identified as A0, A1, ... in the graph (identifier); descriptor writes it as A2 : A0,r1 : c.
+    """
+
+    identifier: str
+    descriptor: str
+    conclusion: str
+    top_rule: str
+    rules: tuple[str, ...] = ()
+    supports: tuple[Argument, ...] = field(default=(), repr=False)
+
+
+@dataclass(frozen=True)
+class Attack:
+    """[attacker] attacks [target], with its type (rebut, undermine, undercut, ...) and the sub-argument it hits."""
+
+    attacker: Argument
+    target: Argument
+    type: Optional[str] = None
+    on: Optional[Argument] = None
+
+
+@dataclass(frozen=True)
+class Support:
+    """[supporter] is an argument [supported] is built on."""
+
+    supporter: Argument
+    supported: Argument
+
+
+@dataclass(frozen=True)
+class LabelledArgument:
+    """An argument with its label: in, out, und (na for an argument the labelling does not label)."""
+
+    argument: Argument
+    label: str
+
+
+@dataclass(frozen=True)
+class Graph:
+    """An argumentation graph: its arguments, the attacks and supports between them, and the label of each argument."""
+
+    arguments: tuple[Argument, ...]
+    attacks: tuple[Attack, ...] = ()
+    supports: tuple[Support, ...] = ()
+    labellings: tuple[LabelledArgument, ...] = ()
+
+    def label(self, argument: Argument) -> Optional[str]:
+        """The label of [argument]: in, out, und, or na for an argument the labelling does not label."""
+        return next((labelled.label for labelled in self.labellings if labelled.argument == argument), None)
+
+    def labelled(self, label: str) -> list[Argument]:
+        """The arguments labelled [label] (in, out, und)."""
+        return [labelled.argument for labelled in self.labellings if labelled.label == label]
+
+    def conclusions(self, label: str) -> list[str]:
+        """The conclusions of the arguments labelled [label] (in, out, und), each once."""
+        return list(dict.fromkeys(argument.conclusion for argument in self.labelled(label)))
+
+
+def graph_from_jvm(graph: Any) -> Graph:
+    """The graph of [graph], a Graph of the library of the JVM."""
+    arguments: dict[str, Argument] = {}
+
+    def argument(of: Any) -> Argument:
+        identifier = str(of.getIdentifier())
+        if identifier not in arguments:
+            arguments[identifier] = Argument(
+                identifier,
+                str(of.getDescriptor()),
+                str(of.getConclusion()),
+                str(of.getTopRule()),
+                tuple(str(rule) for rule in of.getRules()),
+                tuple(argument(support) for support in of.getSupports()),
+            )
+        return arguments[identifier]
+
+    return Graph(
+        tuple(argument(of) for of in graph.getArguments()),
+        tuple(
+            Attack(
+                argument(of.getAttacker()),
+                argument(of.getTarget()),
+                None if of.getType() is None else str(of.getType()),
+                None if of.getOn() is None else argument(of.getOn()),
+            )
+            for of in graph.getAttacks()
+        ),
+        tuple(Support(argument(of.getSupporter()), argument(of.getSupported())) for of in graph.getSupports()),
+        tuple(LabelledArgument(argument(of.getArgument()), str(of.getLabel())) for of in graph.getLabellings()),
+    )

arg2p/parallel.py

@@ -0,0 +1,160 @@
+"""The parallel solver of arg2p: clusters of workers, run in turn (LocalCluster) or on the threads of the JVM
+(ThreadedCluster), federated with other clusters (of the JVM, of Node.js, of browsers) over WebSockets, by address or
+found on the local network."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from . import _jvm
+from .arg2p import call
+from .flags import Flags
+
+_CLUSTER = "it.unibo.tuprolog.argumentation.parallel.cluster"
+
+
+@dataclass(frozen=True)
+class Response:
+    """
+    An argument for the statement evaluated (claim, the statement), with the argument itself in query_chain (empty for
+    a statement no argument concludes), as Prolog text.
+    """
+
+    claim: str
+    query_chain: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class EvaluationResponse:
+    """The arguments for a statement, by label."""
+
+    in_args: list[Response] = field(default_factory=list)
+    out_args: list[Response] = field(default_factory=list)
+    und_args: list[Response] = field(default_factory=list)
+
+
+def _response(response: Any) -> EvaluationResponse:
+    def responses(of: Any) -> list[Response]:
+        return [Response(str(it.getClaim()), tuple(str(argument) for argument in it.getQueryChain())) for it in of]
+
+    return EvaluationResponse(responses(response.getInArgs()), responses(response.getOutArgs()), responses(response.getUndArgs()))
+
+
+def _arguments(*given: Any, defaults: tuple[Any, ...]) -> list[Any]:
+    """
+    The arguments of a constructor of the JVM, up to the last one given: those left out after it take its defaults,
+    those left out before it [defaults] (as the constructor has them)
+    """
+    last = max((i for i, it in enumerate(given) if it is not None), default=-1)
+    return [given[i] if given[i] is not None else defaults[i] for i in range(last + 1)]
+
+
+def _parts(parts: Optional[int]) -> Any:
+    return None if parts is None else _jvm.jclass("java.lang.Integer").valueOf(parts)
+
+
+class LocalCluster:
+    """
+    A distributed solver whose nodes run in turn, on the thread of the caller: the same messages as on a cluster, in a
+    deterministic order. The theory is split into at most [parts] partitions if given, one for each group of rules
+    supporting one another otherwise; the graph is labelled as the standard solver does with [flags].
+    """
+
+    def __init__(self, parts: Optional[int] = None, flags: Optional[Flags] = None) -> None:
+        arguments = _arguments(_parts(parts), flags and flags.jvm(), defaults=(None, None))
+        self._cluster = call(lambda: _jvm.jclass(f"{_CLUSTER}.LocalCluster")(*arguments))
+
+    def load(self, theory: str) -> None:
+        """Replaces the theory with [theory], as Prolog text."""
+        call(lambda: self._cluster.load(theory))
+
+    def add(self, clause: str) -> None:
+        """Adds [clause], as Prolog text, to the theory."""
+        call(lambda: self._cluster.add(clause))
+
+    def reset(self) -> None:
+        """Forgets the theory."""
+        call(self._cluster.reset)
+
+    def solve(self, statement: str) -> EvaluationResponse:
+        """The arguments for [statement], as Prolog text, by label (Arg2pError for one that is not a statement)."""
+        return call(lambda: _response(self._cluster.solve(statement)))
+
+
+class ThreadedCluster:
+    """
+    A distributed solver on the threads of the JVM: each node handles its messages one at a time, the nodes in parallel
+    on [threads] threads (as many as the processors by default). The theory is split into at most [parts] partitions
+    if given, as many as the workers of the cluster and of the sites it is federated with otherwise; the graph is
+    labelled as the standard solver does with [flags]. With query mode (the default) the graph is built on the
+    arguments the statements evaluated depend on, as the standard solver builds it. [lends] tells whether the cluster
+    lends its workers to the others (it does by default).
+    """
+
+    def __init__(
+        self,
+        threads: Optional[int] = None,
+        parts: Optional[int] = None,
+        flags: Optional[Flags] = None,
+        lends: Optional[bool] = None,
+    ) -> None:
+        cluster = _jvm.jclass(f"{_CLUSTER}.ThreadedCluster")
+        # the constructor takes (threads, parts, flags, textual, lends): textual is for the tests of the JVM alone
+        arguments = _arguments(
+            threads,
+            _parts(parts),
+            flags and flags.jvm(),
+            None,
+            lends,
+            defaults=(cluster.getProcessors(), None, Flags.defaults().jvm(), False, None),
+        )
+        self._cluster = call(lambda: cluster(*arguments))
+
+    @property
+    def id(self) -> str:
+        """The identifier of the site of the cluster, as the others know it."""
+        return str(self._cluster.getId())
+
+    @property
+    def peers(self) -> set[str]:
+        """The sites the cluster is federated with."""
+        return {str(peer) for peer in self._cluster.getPeers()}
+
+    def listen(self, port: int = 0, host: str = "0.0.0.0") -> int:
+        """Accepts the links of other sites over WebSockets, on [port] of [host] (an ephemeral port for 0): the port."""
+        return int(call(lambda: self._cluster.listen(port, host)))
+
+    def discover(self) -> None:
+        """Federates the cluster with the clusters of the local network that discover the others as well."""
+        call(self._cluster.discover)
+
+    def connect(self, uri: str) -> None:
+        """Federates the cluster with the site listening at [uri] (ws://host:port)."""
+        call(lambda: self._cluster.connect(uri))
+
+    def load(self, theory: str) -> None:
+        """Replaces the theory with [theory], as Prolog text."""
+        call(lambda: self._cluster.load(theory))
+
+    def add(self, clause: str) -> None:
+        """Adds [clause], as Prolog text, to the theory."""
+        call(lambda: self._cluster.add(clause))
+
+    def reset(self) -> None:
+        """Forgets the theory."""
+        call(self._cluster.reset)
+
+    def solve(self, statement: str) -> EvaluationResponse:
+        """The arguments for [statement], as Prolog text, by label (Arg2pError for one that is not a statement)."""
+        return call(lambda: _response(self._cluster.solve(statement)))
+
+    def close(self) -> None:
+        """Closes the links to the other sites, and stops the threads."""
+        call(self._cluster.close)
+
+    def __enter__(self) -> ThreadedCluster:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()

arg2p/values.py

@@ -0,0 +1,59 @@
+"""The values arg2p gives and takes, as Python values: atoms as strings, numbers as numbers, lists as lists, compound
+terms as [Struct] and variables as [Var] (the Value of the library of the JVM)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Union
+
+
+@dataclass(frozen=True)
+class Var:
+    """A variable, by its name."""
+
+    name: str
+
+    def __str__(self) -> str:
+        return self.name
+
+
+@dataclass(frozen=True)
+class Struct:
+    """A compound term: its functor and arguments, and its text, as arg2p writes it (-a, o(-b))."""
+
+    functor: str
+    args: tuple[Any, ...]
+    text: str = field(default="", compare=False, repr=False)
+
+    @property
+    def arity(self) -> int:
+        return len(self.args)
+
+    def __str__(self) -> str:
+        return self.text or f"{self.functor}({', '.join(map(str, self.args))})"
+
+
+Value = Union[str, int, float, list, Struct, Var]
+
+
+def from_jvm(value: Any) -> Value:
+    """The Python value of [value], a Value of the library of the JVM."""
+    kind = str(value.getKind())
+    if kind == "atom":
+        return str(value.getName())
+    if kind == "integer":
+        return int(value.getValue())
+    if kind == "real":
+        return float(value.getValue())
+    if kind == "variable":
+        return Var(str(value.getName()))
+    if kind == "list":
+        return [from_jvm(item) for item in value.getItems()]
+    return Struct(str(value.getFunctor()), tuple(from_jvm(argument) for argument in value.getArgs()), str(value.toString()))
+
+
+def text(value: Value) -> str:
+    """[value] as Prolog text, as arg2p writes it."""
+    if isinstance(value, list):
+        return "[" + ", ".join(text(item) for item in value) + "]"
+    return str(value)

arg2p-0.19.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: arg2p
+Version: 0.19.0
+Summary: Arg2P, structured argumentation in Prolog (ASPIC+, ABA, abstract frameworks), from Python
+License: MIT
+Project-URL: Homepage, https://tuprolog.github.io/arg2p-kt/
+Project-URL: Source, https://github.com/tuProlog/arg2p-kt
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Java
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: JPype1>=1.5
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+
+# arg2p for Python
+
+[Arg2P](https://github.com/tuProlog/arg2p-kt), structured argumentation in Prolog (ASPIC+, ABA, ABA+, abstract
+frameworks, ...), from Python: the API of the library of the JVM, in snake case, run through
+[JPype](https://jpype.readthedocs.io) on the Java runtime the wheel bundles.
+
+```sh
+pip install arg2p
+```
+
+```python
+from arg2p import Arg2p, Flags, Semantics
+
+arg2p = Arg2p.of("""
+r1 : [] => a.
+r2 : [] => -a.
+sup(r1, r2).
+""")
+
+arg2p.answer("a").in_statements                 # ['a']
+(graph,) = arg2p.graphs()
+graph.conclusions("out")                        # ['-a']
+
+preferred = Arg2p.of("f1 :=> d.\nf2 :=> -d.", Flags.defaults().argument_labelling_mode(Semantics.PREFERRED))
+len(preferred.graphs())                         # 2
+
+Arg2p.of("r1 :=> a.\nr2 : a => b.").causality.but_for("a", "b")   # True
+```
+
+See [the documentation](https://tuprolog.github.io/arg2p-kt/docs/api/python/) for the whole API: flags, graphs,
+Prolog goals, causality, the parallel solver and the command line (`arg2p theory.pl -q a`).
+
+## Building
+
+The package is a project of the Gradle build of Arg2P, which gives it its jars, its version and its Java runtime:
+
+```sh
+./gradlew :python:pythonJars :python:pythonVersion :python:pythonRuntime
+pip install "./python[test]"
+pytest python/tests
+```
+
+Without the runtime (`pythonRuntime`), the package runs on the Java of the system (21 or later). `ARG2P_JVM` names
+another library of the JVM, `ARG2P_CLASSPATH` other jars.

arg2p-0.19.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+arg2p/__init__.py,sha256=VaOaJ19awRuY93DPAzCB5JqaGHFlVAHfCSC8MdAtYZU,1485
+arg2p/__main__.py,sha256=IBERPBnGIm-t3j0CBQz8lCELY2uwkwnELKqnUF7P5Vw,2039
+arg2p/_jvm.py,sha256=lF3GhYYcTtHXmpmnocH_nQAPpo0o2kBlSK5tt_FS9nQ,4670
+arg2p/_version.py,sha256=X03rfGaW8B6UV-zl1XVzVWq_UtJ6lvQ5M9Cu6gVIUiE,104
+arg2p/arg2p.py,sha256=rByUwohd4mWRGcGLtm8ZTtyM7f2dKTXDxTA8y5LN9jk,10814
+arg2p/flags.py,sha256=qgTa2N7FopZYivMz3EUth986e35gye52c7xDSITDc3I,7681
+arg2p/model.py,sha256=RUtyw0N6bWeRo6Mrb1EXuzqPdr--CFAwUPPPoccFu6A,3626
+arg2p/parallel.py,sha256=HUGEny_z2WYqgrYBJunNLttme4Yc4DrYVHt8VPENGWk,6511
+arg2p/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arg2p/values.py,sha256=CQTeZzlOFbp2Usvh6d8H4bFJ-CNzW0SD144th8BgId4,1745
+arg2p/jars/Java-WebSocket-1.6.0.jar,sha256=6uKSE-TxZRVjnCiVcgDwEbOWf__K2hlizwJV0kkZwi8,140686
+arg2p/jars/annotations-13.0.jar,sha256=rOKhDcji1f00kl7KwD5JiLLA-FFlDJS4zvSbob0RFHg,17536
+arg2p/jars/arg2p-jvm-0.19.0.jar,sha256=Nq935txV2kDy38S82YZxvGtSdm9wgr8sVlGiXowATvI,23984
+arg2p/jars/causality-solver-jvm-0.19.0.jar,sha256=gq2xesJatdYI4_uL2a3e_WV-DE8p58n7tqajHAV-QdQ,29646
+arg2p/jars/core-jvm-0.19.0.jar,sha256=9t21VrkMpi9su5E9vIKsAhwCTDmEB4m8eBlwgQhI3DY,803054
+arg2p/jars/core-jvm-3.0.5.jar,sha256=W8JsG1g2admKcubqpIFESmtofvuhem_d1SbfHzZYxIo,514768
+arg2p/jars/dsl-core-jvm-3.0.5.jar,sha256=bLpuEIka4AcqIMrYTWsYi52VYMOnxXAGu_Jmcno3ibM,95802
+arg2p/jars/dsl-solve-jvm-3.0.5.jar,sha256=7tuvf0XC0FQcLhZgZPmT4WNyATDPxOLb-iV6ZVsxBbc,44014
+arg2p/jars/dsl-theory-jvm-3.0.5.jar,sha256=SyDumXmzuv-YvDx3jEaRbfmX5JfeQ41cO2j7jtNh7HA,38502
+arg2p/jars/dsl-unify-jvm-3.0.5.jar,sha256=aABWIQEEoMF7Vs31kKN6hBNlKjx0M4WTVjpv-1QoGKI,35118
+arg2p/jars/io-lib-jvm-3.0.5.jar,sha256=2ICtLyI27Y0AtdGpQELS4NgQmRecZ_NN-R28fkpsWkY,163252
+arg2p/jars/kotlin-reflect-2.4.21.jar,sha256=fJ6L2jyvqFtlaSBlrNIleLKEMpK05LqoNhvckXV0bog,3808541
+arg2p/jars/kotlin-stdlib-2.4.21.jar,sha256=vYJQIQWEy2WYR9zpzaZg-OmQbl3vf7686pPcbctqiKM,1853315
+arg2p/jars/kotlin-stdlib-jdk7-2.4.21.jar,sha256=b86GfUwkySqLZMlmMX06wdS3h6AOGqbSt2sc7dOgwII,940
+arg2p/jars/kotlin-stdlib-jdk8-2.4.21.jar,sha256=64PLwH7mj81fIpsu0dZsegF1xWrB3KFFfM5LFwIAQlk,946
+arg2p/jars/kt-math-jvm-0.10.2.jar,sha256=0nRGvmUidmbv5DDVXMbvNkcHWbSVIXiiMysNcKu3JBc,179877
+arg2p/jars/okio-jvm-3.18.2.jar,sha256=aB_tVJ0dLGNxD0LJ6rQz1kLHGvd4ur1nA1xQ-MQlqv8,392462
+arg2p/jars/parallel-solver-jvm-0.19.0.jar,sha256=mFkWvFV-Ab_DFRFzrGzxKZ6urqK50p4GhA7OzT4_Nws,199455
+arg2p/jars/parser-core-jvm-3.0.5.jar,sha256=sAvBRMjPBxMHUAYAmpiU7VAA9Vkeu1r6bkxYW-Qll9E,38199
+arg2p/jars/parser-impl-jvm-3.0.5.jar,sha256=KXlQDl-hoaG0sRSjK8zz4DGXnBFsLr5OdaFAe6wJCw8,279480
+arg2p/jars/parser-theory-jvm-3.0.5.jar,sha256=qL_uRjKMUMtZcFtCCLJsL7NWSXr5-UYOQEckEHW2pUI,22496
+arg2p/jars/slf4j-api-2.0.13.jar,sha256=58KkjoUVuh9J-mN9V7Ti9ZCz9b2XQHrGmcOqXvsSBKk,68605
+arg2p/jars/solve-jvm-3.0.5.jar,sha256=hkpXrzHMGM1I-zPv_ZsMmpR-8ygSgS7hsSSX2-M6w54,931229
+arg2p/jars/theory-jvm-3.0.5.jar,sha256=4UhU54ELaaheyQorPYFY5_e_52NZeTjbeLoGT2Gu_Pk,265790
+arg2p/jars/unify-jvm-3.0.5.jar,sha256=_3qdo05PayxsoZFPvrKeUeCIoZZUSVDWBaCP0z3ihiw,60745
+arg2p/jars/utils-jvm-3.0.5.jar,sha256=Cbg4lCn-XC8-ekinha_JdywjEJ7cq69cz9PE4DQFiac,156120
+arg2p-0.19.0.dist-info/METADATA,sha256=gqDR-DKVdiYRlJC2jqHrLhrFm4W650D233thSFXzGnM,2117
+arg2p-0.19.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+arg2p-0.19.0.dist-info/entry_points.txt,sha256=xKVvdOCOFphBOAu3DDC2C8z0S46Twj23c78iHGDIpwM,46
+arg2p-0.19.0.dist-info/top_level.txt,sha256=m2bPCzU2ZXpzuE8dHtKOP9xjcisi2mFm_sDKVgOzzE4,6
+arg2p-0.19.0.dist-info/RECORD,,

arg2p-0.19.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

arg2p-0.19.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+arg2p = arg2p.__main__:main

arg2p-0.19.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+arg2p