agentforge-framework 0.2.0__py3-none-any.whl

agentforge_framework/core/skills.py

@@ -0,0 +1,255 @@
+"""Access to the skill bundle.
+
+Skills ship as package data, never as importable modules. Markdown is read as
+text; Python is invoked as a subprocess through the Command Runner, which is the
+one process boundary in the codebase.
+
+Most of the bundle is vendored third-party work (ADR-0006) and never edited in
+place. A few skills are AgentForge's own; `FIRST_PARTY` names them, because a
+refresh re-copies upstream over this directory and anything of ours that is not
+findable goes with it.
+
+One of ours is a composite: a skill whose job is to run two others together on
+one task. `COMPOSED` says what each expands to, because a composite has to
+survive both Capability Tiers — natively it fans out through the Skill tool, and
+as a Fragment there is no tool to fan out with, so the delivery path inlines what
+it names.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .process import CommandRunner, SubprocessRunner
+
+SKILLS_ROOT = Path(__file__).resolve().parent.parent / "skills"
+
+#: Scanners the `unslop` Command runs, in report order. The remaining scripts in
+#: the bundle serve upstream's voice and calibration features and are not wired
+#: into AgentForge.
+UNSLOP_SCANNERS = (
+    "banned_phrase_scan.py",
+    "structure_scan.py",
+    "silhouette_scan.py",
+)
+
+
+#: Every skill in the bundle that AgentForge wrote. Not all of them are
+#: composites — `write-plainly` is derived from what the scanners above enforce
+#: and composes nothing — so this is the list a refresh has to be careful of,
+#: and `COMPOSED` is not.
+FIRST_PARTY: tuple[str, ...] = ("grill-with-docs", "write-plainly")
+
+
+#: The composites, and the vendored skills each is built out of. A composite adds
+#: the job the parts are doing together and restates neither: a Fragment is the
+#: degraded delivery of a skill and never a second copy of one, so the method
+#: stays in exactly one file.
+COMPOSED: dict[str, tuple[str, ...]] = {
+    "grill-with-docs": ("grilling", "domain-modeling"),
+}
+
+
+def expand(names: Sequence[str]) -> tuple[str, ...]:
+    """Declared skills, with each composite followed by what it is made of.
+
+    Order matters and duplicates do not survive it: the composite states the job
+    before the methods it draws on, and a Role that declared a part directly as
+    well gets it once.
+    """
+    ordered: list[str] = []
+    for name in names:
+        for part in (name, *COMPOSED.get(name, ())):
+            if part not in ordered:
+                ordered.append(part)
+    return tuple(ordered)
+
+
+class SkillNotFound(LookupError):
+    """A skill was requested that is not in the vendored bundle."""
+
+
+def skill_path(name: str) -> Path:
+    """Return the directory of a vendored skill."""
+    path = SKILLS_ROOT / name
+    if not path.is_dir():
+        available = ", ".join(sorted(p.name for p in SKILLS_ROOT.iterdir() if p.is_dir()))
+        raise SkillNotFound(f"no vendored skill named {name!r}; available: {available}")
+    return path
+
+
+def read_skill(name: str) -> str:
+    """Return a skill's SKILL.md as text, for prompt-fragment delivery."""
+    return (skill_path(name) / "SKILL.md").read_text(encoding="utf-8")
+
+
+@dataclass(frozen=True)
+class ScanResult:
+    """One scanner's verdict on one file."""
+
+    scanner: str
+    violations: int
+    clean: bool
+    report: dict | None = None
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class UnslopReport:
+    """The aggregate verdict across every scanner."""
+
+    path: Path
+    results: list[ScanResult] = field(default_factory=list)
+
+    @property
+    def violations(self) -> int:
+        return sum(r.violations for r in self.results)
+
+    @property
+    def clean(self) -> bool:
+        return all(r.clean for r in self.results)
+
+    @property
+    def failed(self) -> list[ScanResult]:
+        """Scanners that could not run at all, as distinct from ones that found faults."""
+        return [r for r in self.results if r.error is not None]
+
+    def to_dict(self) -> dict:
+        return {
+            "path": str(self.path),
+            "clean": self.clean,
+            "violations": self.violations,
+            "scanners": {
+                r.scanner: (
+                    {"error": r.error}
+                    if r.error
+                    else {"violations": r.violations, "clean": r.clean, "report": r.report}
+                )
+                for r in self.results
+            },
+        }
+
+
+def _count_violations(report: dict) -> int:
+    """Pull a violation count out of a scanner report.
+
+    The scanners agree on exit codes but not on payload shape:
+
+    - ``banned_phrase_scan`` reports ``total_violations`` plus a ``violations`` list.
+    - ``structure_scan`` and ``silhouette_scan`` report a ``flags`` list and a
+      ``flagged`` dict keyed by metric name.
+
+    Exit code remains the authority on pass or fail; this is only for reporting
+    how much was found.
+    """
+    total = report.get("total_violations")
+    if isinstance(total, int):
+        return total
+
+    for key in ("violations", "flags"):
+        value = report.get(key)
+        if isinstance(value, list):
+            return len(value)
+
+    flagged = report.get("flagged")
+    if isinstance(flagged, dict):
+        return sum(1 for hit in flagged.values() if hit)
+
+    return 0
+
+
+def _describe(result: ScanResult) -> list[str]:
+    """One line per finding, using whichever detail keys the scanner provides."""
+    if not result.report:
+        return []
+
+    # `or ""` rather than a `get` default throughout: the scanners write an
+    # explicit null where they have no suggestion, and a default only fires on a
+    # missing key. The line read "'in today's' - None" until this was found by
+    # running the real scanners over real prose.
+    lines: list[str] = []
+    for violation in result.report.get("violations", []):
+        where = violation.get("line_number") or "?"
+        phrase = violation.get("phrase") or "?"
+        suggestion = violation.get("suggestion") or ""
+        lines.append(f"line {where}: {phrase!r} - {suggestion}".rstrip(" -"))
+    for flag in result.report.get("flags", []):
+        metric = flag.get("metric") or "?"
+        detail = flag.get("detail") or ""
+        suggestion = flag.get("suggestion") or ""
+        lines.append(f"{metric}: {detail} {suggestion}".strip())
+    return lines
+
+
+def render_report(report: UnslopReport) -> list[str]:
+    """One line per scanner, and one per finding beneath it.
+
+    Shared by the Reviewer's Run Log entry and its own rewrite prompt, which is
+    the point: what a human reads about the prose and what the Role is asked to
+    act on are the same text, so neither can quietly say more than the other.
+    """
+    lines: list[str] = []
+    for result in report.results:
+        if result.error:
+            lines.append(f"- {result.scanner}: could not run — {result.error}")
+            continue
+        verdict = "clean" if result.clean else f"{result.violations} finding(s)"
+        lines.append(f"- {result.scanner}: {verdict}")
+        lines += [f"    - {line}" for line in _describe(result)]
+    return lines
+
+
+def run_unslop(
+    path: str | Path,
+    scanners: tuple[str, ...] = UNSLOP_SCANNERS,
+    runner: CommandRunner | None = None,
+) -> UnslopReport:
+    """Scan a file for machine-writing tells. Deterministic: no model involved."""
+    target = Path(path).resolve()
+    if not target.is_file():
+        raise FileNotFoundError(target)
+
+    runner = runner or SubprocessRunner()
+    scripts = skill_path("unslop") / "scripts"
+    results: list[ScanResult] = []
+
+    for scanner in scanners:
+        script = scripts / scanner
+        if not script.is_file():
+            results.append(
+                ScanResult(scanner, violations=0, clean=True, error=f"missing script: {script}")
+            )
+            continue
+
+        completed = runner.run([sys.executable, str(script), str(target)])
+
+        try:
+            report = json.loads(completed.stdout)
+        except json.JSONDecodeError:
+            detail = (completed.stderr or completed.stdout or "").strip()
+            results.append(
+                ScanResult(
+                    scanner,
+                    violations=0,
+                    clean=True,
+                    error=f"unparsable output (exit {completed.returncode}): {detail[:400]}",
+                )
+            )
+            continue
+
+        # The scanners exit 1 when they find something, so a non-zero exit is a
+        # verdict rather than a crash. Trust the payload for the count.
+        results.append(
+            ScanResult(
+                scanner,
+                violations=_count_violations(report),
+                clean=completed.returncode == 0,
+                report=report,
+            )
+        )
+
+    return UnslopReport(path=target, results=results)

agentforge_framework/core/workflow.py

@@ -0,0 +1,215 @@
+"""Workflow definitions: the Roster as data rather than as Python.
+
+A Workflow is a YAML-declared sequence of Roles with Gates between them. The
+runtime walks the steps; it does not know which Roles exist, which is what makes
+adding a seventh Role a definition and a line of YAML rather than an edit to the
+engine.
+
+Everything here happens before a Provider is invoked. A definition naming a Role
+that cannot run, a Gate kind that does not exist, or a tier that was never a
+tier is refused at load time, so a typo in a Workflow costs nothing rather than
+costing a deep-tier planning pass.
+
+A Step declares four things. The Role is resolved and run, the Model Tier
+override is applied for that invocation, and the Gate is looked up in
+`core.gates` and evaluated once the Step is behind the Run. The skip condition is
+parsed and carried, waiting for the conditional-step work.
+
+Every entry point here takes the Gate table to validate against, defaulting to
+the shipped one. A Run with active Plugins passes the wider table
+`core.registry` assembles, so a definition naming a Plugin's Gate kind loads
+where that Plugin is active and is refused where it is not — which is the
+honest answer, since nothing would evaluate it there. Nothing in this module
+knows what a Plugin is.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+from ..agents import UnknownRole, resolve_role
+from .contracts import ModelTier, outstanding
+from .gates import GATES, GateCheck
+
+#: Shipped definitions live beside the package, like the vendored skills.
+WORKFLOWS_ROOT = Path(__file__).resolve().parent.parent / "workflows"
+
+
+class WorkflowError(ValueError):
+    """A Workflow definition cannot be used. The message names the file and the fault."""
+
+
+@dataclass(frozen=True)
+class Step:
+    """One Role invocation, plus the three things that qualify it.
+
+    `tier` overrides the Role's ADR-0004 default for this step alone. `gate`
+    names the kind of Gate that must clear before the next step begins. `when` is
+    the condition under which the step is skipped, and is not acted on yet.
+    """
+
+    role: str
+    tier: ModelTier | None = None
+    gate: str | None = None
+    when: str | None = None
+
+
+@dataclass(frozen=True)
+class Workflow:
+    """An ordered sequence of Steps, named."""
+
+    name: str
+    steps: tuple[Step, ...] = ()
+
+    def remaining(self, done: tuple[str, ...]) -> tuple[Step, ...]:
+        """Steps that have not yet completed, in definition order."""
+        return outstanding(self.steps, done, lambda step: step.role)
+
+
+def available_workflows(
+    root: Path | None = None, gates: Mapping[str, GateCheck] | None = None
+) -> tuple[Workflow, ...]:
+    """Every definition that loads, by name.
+
+    The Orchestrator picks one and names it in the Issue, so it has to be told
+    what there is. Read off the directory rather than listed in a prompt, so a
+    project that drops a definition beside the shipped ones can have it chosen.
+    A definition that does not load is left out rather than raising: one bad
+    file in the directory should not stop planning against the others.
+    """
+    directory = Path(root) if root is not None else WORKFLOWS_ROOT
+    workflows = []
+    for path in sorted(directory.glob("*.yaml")):
+        try:
+            workflows.append(
+                parse_workflow(path.read_text(encoding="utf-8"), name=path.stem, gates=gates)
+            )
+        except WorkflowError:
+            continue
+    return tuple(workflows)
+
+
+def load_workflow(
+    name: str, root: Path | None = None, gates: Mapping[str, GateCheck] | None = None
+) -> Workflow:
+    """Read and validate one definition by name."""
+    directory = Path(root) if root is not None else WORKFLOWS_ROOT
+    path = directory / f"{name}.yaml"
+    if not path.is_file():
+        available = ", ".join(sorted(p.stem for p in directory.glob("*.yaml")))
+        raise WorkflowError(
+            f"no Workflow named {name!r} in {directory}; available: {available or 'none'}"
+        )
+    return parse_workflow(path.read_text(encoding="utf-8"), name=name, gates=gates)
+
+
+def parse_workflow(
+    text: str, *, name: str, gates: Mapping[str, GateCheck] | None = None
+) -> Workflow:
+    """Validate a definition's text. Every rejection names `name` and the fault."""
+    try:
+        data = yaml.safe_load(text)
+    except yaml.YAMLError as exc:
+        raise WorkflowError(f"Workflow {name!r} is not valid YAML: {exc}") from exc
+
+    if not isinstance(data, dict):
+        raise WorkflowError(f"Workflow {name!r} must be a mapping, not {_kind(data)}")
+
+    if "steps" not in data:
+        raise WorkflowError(f"Workflow {name!r} declares no `steps`")
+
+    raw_steps = data["steps"] or []
+    if not isinstance(raw_steps, list):
+        raise WorkflowError(f"Workflow {name!r}: `steps` must be a list, not {_kind(raw_steps)}")
+
+    steps = tuple(
+        _parse_step(raw, index=index, workflow=name, gates=gates)
+        for index, raw in enumerate(raw_steps, start=1)
+    )
+    return Workflow(name=str(data.get("name") or name), steps=steps)
+
+
+def _parse_step(
+    raw: object, *, index: int, workflow: str, gates: Mapping[str, GateCheck] | None
+) -> Step:
+    where = f"Workflow {workflow!r} step {index}"
+
+    if not isinstance(raw, dict):
+        raise WorkflowError(f"{where} must be a mapping with a `role`, not {_kind(raw)}")
+
+    role = raw.get("role")
+    if not role or not isinstance(role, str):
+        raise WorkflowError(f"{where} declares no `role`")
+
+    try:
+        resolve_role(role)
+    except UnknownRole as exc:
+        raise WorkflowError(f"{where} names {role!r}: {exc}") from exc
+
+    return Step(
+        role=role.strip().lower(),
+        tier=_parse_tier(raw.get("tier"), where=where),
+        gate=_parse_gate(raw.get("gate"), where=where, gates=gates),
+        when=_optional_str(raw.get("when")),
+    )
+
+
+def _parse_tier(value: object, *, where: str) -> ModelTier | None:
+    if value is None:
+        return None
+    try:
+        return ModelTier(str(value).strip().lower())
+    except ValueError as exc:
+        tiers = ", ".join(tier.value for tier in ModelTier)
+        raise WorkflowError(f"{where} names tier {value!r}; tiers are: {tiers}") from exc
+
+
+def _parse_gate(
+    value: object, *, where: str, gates: Mapping[str, GateCheck] | None
+) -> str | None:
+    """A Gate kind is valid when something in this Run is registered to evaluate it.
+
+    Validated against the table rather than a list kept here: two lists would
+    let a definition name a Gate nothing answers for, which is a check that
+    silently never runs. `None` means the shipped table, and a Run hands in the
+    one its active Plugins widened.
+
+    The rejection names the kinds that are available rather than the kinds that
+    exist somewhere, because the reader's next question is what to write
+    instead: a definition naming a Plugin's Gate in a repository that Plugin does
+    not answer for is refused, and the list says so by leaving it out.
+    """
+    if value is None:
+        return None
+    table = GATES if gates is None else gates
+    kind = str(value).strip().lower()
+    if kind not in table:
+        kinds = ", ".join(sorted(table))
+        raise WorkflowError(f"{where} names Gate kind {value!r}; kinds are: {kinds}")
+    return kind
+
+
+def _optional_str(value: object) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _kind(value: object) -> str:
+    return type(value).__name__
+
+
+__all__ = [
+    "WORKFLOWS_ROOT",
+    "Step",
+    "Workflow",
+    "WorkflowError",
+    "available_workflows",
+    "load_workflow",
+    "parse_workflow",
+]

agentforge_framework/plugins/__init__.py

@@ -0,0 +1,35 @@
+"""AgentForge plugin packages.
+
+`BUILT_IN` is the registry: a tuple rather than a dict or a set, because
+activation order is the order Fragments reach a prompt in, and a reader
+comparing two Run Logs should not have to wonder whether the order meant
+anything. Registration is an entry here and a module beside it.
+
+Order is also precedence where two Plugins claim one file suffix: the first
+registered wins, and `core.registry.extractors_for` is where that is stated and
+applied. `python` before `sql` is not a judgement about which matters more —
+they claim disjoint suffixes — but the tuple is the tie-breaker the day two of
+them do not.
+
+The general before the specific, which is the order a reader wants them in: a
+PySpark job is Python and is held to both, and the Fragment about annotating a
+public function reaches its prompt before the one about the DataFrame API. The
+four are also four different worked examples of the interface — `python`
+contributes Fragments and nothing else, `sql` Extractors and nothing else,
+`pyspark` is detected by what a file imports, and `databricks` by a marker at
+the root and speaks differently to different Roles — so the fifth Plugin is
+written by reading the one nearest to it rather than by reading the framework.
+"""
+
+from __future__ import annotations
+
+from ..core.contracts import Plugin
+from .databricks import DATABRICKS
+from .pyspark import PYSPARK
+from .python import PYTHON
+from .sql import SQL
+
+#: Every Plugin AgentForge ships, in the order they contribute.
+BUILT_IN: tuple[Plugin, ...] = (PYTHON, SQL, PYSPARK, DATABRICKS)
+
+__all__ = ["BUILT_IN", "DATABRICKS", "PYSPARK", "PYTHON", "SQL"]

agentforge_framework/plugins/databricks/__init__.py

@@ -0,0 +1,86 @@
+"""The Databricks Plugin: what a workspace's code is held to, and what to audit.
+
+A worked example of two things the other Plugins do not show.
+
+**Detection by root marker alone.** A Databricks repository is one wherever the
+work lands: a bundle's `databricks.yml` says the code in this tree is deployed
+to a workspace, and that is true of a Plan touching one SQL file and of a Plan
+touching one notebook. Unlike `pyspark` there is no import to read — the runtime
+binds `spark` and `dbutils` for you, so a notebook that uses the whole platform
+can import nothing at all — and unlike `python` the fact is a property of the
+repository rather than of the blast radius.
+
+**A Fragment that differs by Role.** What the Security Role needs to know about
+a workspace is not what the Implementer needs. The Implementer is writing a
+MERGE and needs the idiom this shop writes; the Security Role is auditing the
+same file and needs to know where the secrets are meant to come from and which
+grant is too wide. One Fragment each, keyed to the Roles that want them, because
+the registry hands one Fragment per Plugin to one Role — the Implementer reading
+a paragraph about service principals is paying for advice it cannot act on.
+"""
+
+from __future__ import annotations
+
+from ...core.contracts import Fragment, Plugin
+
+#: What the Roles that write and review the code are held to. Three-part naming
+#: and MERGE are here because they are what a reviewer rejects on sight and what
+#: an Implementer reinvents every Run.
+_CONVENTIONS = """\
+Follow these Databricks conventions unless the code you are editing plainly does otherwise:
+
+- Name every table in full: `catalog.schema.table`. A bare or two-part name
+  resolves against whatever `USE` ran last, so it reads correctly in the
+  notebook that wrote it and nowhere else. The catalog is configuration — take
+  it from the job's parameters rather than hard-coding the production one.
+- Upsert with `MERGE INTO`, not delete-then-insert. Two statements are two
+  chances to leave the table short, and the window between them is one a
+  reader will hit.
+- Match a MERGE on the business key, and write `WHEN MATCHED THEN UPDATE SET`
+  column by column rather than `SET *`, so a new source column cannot silently
+  overwrite a target one.
+- Deduplicate the source before a MERGE. Two source rows for one key fail the
+  whole statement at run time, which is how a MERGE that passed on a sample
+  breaks in production.
+- Do not repair a subset of rows with `INSERT OVERWRITE` on a managed table.
+  Delete or merge what is wrong.
+- Change a table's layout with table properties, `OPTIMIZE`, and `ZORDER`
+  rather than by rewriting it. A rewrite breaks every reader mid-flight.\
+"""
+
+#: The same repository read as a target rather than as a codebase. Every line is
+#: something the Security Role can find in a diff and name a location for, which
+#: is what its Findings are made of.
+_POSTURE = """\
+Audit Databricks code against these, and report what you find rather than fixing it:
+
+- Secrets are fetched at run time from a secret scope — `dbutils.secrets.get`.
+  A token, storage key, or JDBC password written into a notebook, a job
+  definition, or a checked-in config is a Finding whatever the repository's
+  visibility, and so is a secret printed, logged, or written to a table.
+- A job runs as a service principal holding its own grants. A personal access
+  token in a job definition or a bundle outlives the person it belongs to and
+  carries every permission they have.
+- Access is granted in Unity Catalog on the narrowest object that answers the
+  need. A `GRANT` widened to the schema or the catalog to unblock one query is
+  the Finding, and so is `ALL PRIVILEGES` where `SELECT` was the requirement.
+- Notebook widgets and job parameters are user input. Concatenated into a SQL
+  string they are injection; they belong in bound parameters.
+- Sensitive data does not belong on the DBFS root, which every workspace user
+  can read. A Unity Catalog volume or an external location is where it goes.\
+"""
+
+DATABRICKS = Plugin(
+    name="databricks",
+    # A bundle's descriptor under either spelling, and the CLI's profile file
+    # for a repository that predates bundles. Not `.databricks/`: that directory
+    # is local state the tooling writes and the repository ignores, so it says
+    # something about one machine rather than about the code.
+    root_markers=("databricks.yml", "databricks.yaml", ".databrickscfg"),
+    fragments=(
+        Fragment(text=_CONVENTIONS, roles=("implementer", "tester", "reviewer")),
+        Fragment(text=_POSTURE, roles=("security",)),
+    ),
+)
+
+__all__ = ["DATABRICKS"]

agentforge_framework/plugins/pyspark/__init__.py

@@ -0,0 +1,57 @@
+"""The PySpark Plugin: what a Spark job is held to, wherever it lives.
+
+A worked example of detection by import. `.py` is the suffix of a Spark job and
+of a Django view and of this file, and holding all three to the DataFrame API
+would be the fastest way to make a Plugin something people switch off. So this
+Plugin declares no suffix at all: it answers for `pyspark`, and `core.registry`
+reads the Python files the frozen Plan names to find out whether any of them
+imports it. A repository with Spark jobs in it and a Plan that touches none of
+them hears nothing, which is the same bargain the `python` Plugin makes by
+declaring no root markers.
+
+One Fragment, keyed to the three Roles that produce or judge code. The Security
+Role is absent for the reason it is absent from the `python` Plugin: `.rdd` is
+not a vulnerability, and a style convention in a security prompt competes with
+the audit rather than supporting it. What the Security Role does need to know
+about a Spark platform is a workspace's business, and the `databricks` Plugin
+is where that Fragment lives.
+"""
+
+from __future__ import annotations
+
+from ...core.contracts import Fragment, Plugin
+
+#: Every line here changes what an Agent produces. Spark conventions an Agent
+#: would have followed anyway — name your DataFrames well, do not swallow
+#: exceptions — are the `python` Fragment's job or nobody's, and repeating them
+#: is tokens spent on agreement.
+_CONVENTIONS = """\
+Follow these PySpark conventions unless the module you are editing plainly does otherwise:
+
+- Write DataFrame and Column expressions, not RDDs. `.rdd`, `map`, and
+  `flatMap` leave the optimiser out of the work, so a job that reaches for them
+  pays for a planner it refuses to use. Dropping to RDD for something the
+  DataFrame API already does is a defect.
+- Reach for `pyspark.sql.functions`, imported as `F`, before writing a UDF. A
+  Python UDF serialises every row across the JVM boundary; where one is needed,
+  say in a comment which built-in was missing.
+- Read with a declared schema. `inferSchema` reads the source twice and makes
+  the schema whatever last week's file happened to contain.
+- Select the columns you need and join on named keys. A `select("*")` after a
+  join carries duplicated names downstream, and the error names the column
+  rather than the line that made it.
+- Do not `collect()` or `toPandas()` a frame you have not bounded. Aggregate,
+  filter, or `limit` first: the driver holds whatever comes back.
+- Tests build a local session and assert on small frames; one that needs a
+  cluster is not a test this repository can run.\
+"""
+
+PYSPARK = Plugin(
+    name="pyspark",
+    imports=("pyspark",),
+    fragments=(
+        Fragment(text=_CONVENTIONS, roles=("implementer", "tester", "reviewer")),
+    ),
+)
+
+__all__ = ["PYSPARK"]