@toloka-platform/sdk 0.1.0-preview.3

package/examples/video-pair-rating/nodes/finalize_overall/node.ts

@@ -0,0 +1,68 @@
+import { code } from "@toloka-platform/sdk";
+import * as f from "../../fields";
+
+export const finalizeOverall = code("finalize_overall", {
+  about: {
+    name: "finalize_overall",
+    description:
+      "Combines cascade-derived and manually adjudicated Overall Preference into the final output. Re-runs the cascade against post-adjudication metrics and falls back to the manual quorum majority vote when both cascade tiers are tied.",
+  },
+  envVars: [],
+  fieldProxies: {
+    input: [
+      { field: f.opValueOrNull, optional: true },
+      { field: f.opSource, optional: false },
+      { field: f.needsOverallManual, optional: false },
+      { field: f.finalMetrics, optional: false },
+      { field: f.finalOpValue, optional: true },
+      { field: f.finalOpResolutionMethod, optional: true },
+      { field: f.finalOpAdjudicatorId, optional: true },
+      { field: f.resolutionMethod, optional: false },
+      { field: f.annotatorIdAdjudicator, optional: true },
+    ],
+    output: [
+      { field: f.overallPreference, optional: false },
+      { field: f.overallPreferenceSource, optional: false },
+      { field: f.resolutionMethod, optional: false },
+      { field: f.annotatorIdAdjudicator, optional: false },
+    ],
+  },
+  code: {
+    code: `from main_types import Inputs, Outputs
+
+
+async def main(inputs: Inputs) -> Outputs:
+    needs_manual = inputs.get("needs_overall_manual", "false") == "true"
+
+    if needs_manual:
+        # OP came from the manual quorum + optional OP adjudication branch.
+        final_op = inputs.get("final_op_value")
+        method = inputs.get("final_op_resolution_method") or "agreement"
+        op_adj_id = inputs.get("final_op_adjudicator_id")
+        # Fallback if merge branch didn't run for some reason.
+        if final_op is None:
+            final_op = "tie"
+        return {
+            "overall_preference": final_op,
+            "overall_preference_source": "manual",
+            "resolution_method": method,
+            "annotator_id_adjudicator": op_adj_id
+            if op_adj_id is not None
+            else inputs.get("annotator_id_adjudicator"),
+        }
+
+    # Cascade-derived OP.
+    op_value = inputs.get("op_value_or_null")
+    op_source = inputs.get("op_source") or "manual"
+    # Defensive: if cascade said not-manual but returned no value, tie.
+    if op_value is None:
+        op_value = "tie"
+    return {
+        "overall_preference": op_value,
+        "overall_preference_source": op_source,
+        # Metric-branch resolution method still comes from merge_adjudication.
+        "resolution_method": inputs.get("resolution_method") or "agreement",
+        "annotator_id_adjudicator": inputs.get("annotator_id_adjudicator"),
+    }`,
+  },
+});

package/examples/video-pair-rating/nodes/merge_adjudication/node.ts

@@ -0,0 +1,124 @@
+import { code } from "@toloka-platform/sdk";
+import {
+  perMetricResolved,
+  adjudicatedMetrics,
+  disagreedMetrics,
+  finalMetrics,
+  resolutionMethod,
+  annotatorIdAdjudicator,
+  opValueOrNull,
+  opSource,
+  needsOverallManual,
+} from "../../fields";
+
+export const mergeAdjudication = code("merge_adjudication", {
+  about: {
+    name: "merge_adjudication",
+    description:
+      "Merges majority-vote per-metric resolutions from the cascade with adjudicator overrides on disagreed metrics into final_metrics. Also stamps annotator_id_adjudicator and resolution_method.",
+  },
+  envVars: [],
+  fieldProxies: {
+    input: [
+      { field: perMetricResolved, optional: false },
+      { field: adjudicatedMetrics, optional: true },
+      { field: disagreedMetrics, optional: true },
+    ],
+    output: [
+      { field: finalMetrics, optional: false },
+      { field: resolutionMethod, optional: false },
+      { field: annotatorIdAdjudicator, optional: false },
+      { field: opValueOrNull, optional: false },
+      { field: opSource, optional: false },
+      { field: needsOverallManual, optional: false },
+    ],
+  },
+  code: {
+    code: `from main_types import Inputs, Outputs
+
+METRICS_TASK_A = ["image_text_alignment", "motion_text_alignment"]
+METRICS_TASK_B = [
+    "image_quality",
+    "motion_quality",
+    "subject_background_consistency",
+    "video_realism",
+]
+PER_METRIC_FIELDS = METRICS_TASK_A + METRICS_TASK_B
+
+
+def _recompute_cascade(final_metrics: dict) -> tuple:
+    """Re-run the OP cascade against post-adjudication final_metrics.
+    Returns (op_value_or_null, op_source, needs_overall_manual).
+
+    Rule:
+      Tier 1: image_text_alignment in {video_a, video_b} -> alignment
+      Tier 2: image_quality in {video_a, video_b} (NOT tie, NOT none) -> quality
+      Otherwise: manual (route to manual OP quorum)
+    """
+    ita = final_metrics.get("image_text_alignment")
+    iq = final_metrics.get("image_quality")
+
+    if ita in ("video_a", "video_b"):
+        return ita, "alignment", "false"
+    if iq in ("video_a", "video_b"):
+        return iq, "quality", "false"
+    return None, "manual", "true"
+
+
+async def main(inputs: Inputs) -> Outputs:
+    per_metric_resolved = dict(inputs.get("per_metric_resolved") or {})
+    adjudicated_metrics_raw = inputs.get("adjudicated_metrics")
+
+    # adjudicated_metrics is optional (may be None when no adjudication ran).
+    # It's expected to be a dict like: {"metrics": {...}, "annotator_id": "..."}
+    # or a plain dict of metric -> value depending on how the adjudicator
+    # entity is shaped. Support both shapes defensively.
+    adjudicator_id = None
+    adjudicated_map = {}
+
+    if adjudicated_metrics_raw:
+        if isinstance(adjudicated_metrics_raw, dict):
+            # Shape A: {"metrics": {metric: value, ...}, "annotator_id": "..."}
+            if "metrics" in adjudicated_metrics_raw and isinstance(
+                adjudicated_metrics_raw["metrics"], dict
+            ):
+                adjudicated_map = dict(adjudicated_metrics_raw["metrics"])
+                adjudicator_id = adjudicated_metrics_raw.get("annotator_id")
+            else:
+                # Shape B: {metric: value, ...} — no annotator id stamped separately.
+                adjudicated_map = {
+                    k: v for k, v in adjudicated_metrics_raw.items()
+                    if k in PER_METRIC_FIELDS
+                }
+                adjudicator_id = adjudicated_metrics_raw.get("annotator_id")
+
+    ran_adjudication = len(adjudicated_map) > 0
+
+    final_metrics = {}
+    for metric in PER_METRIC_FIELDS:
+        if metric in adjudicated_map:
+            final_metrics[metric] = adjudicated_map[metric]
+        elif metric in per_metric_resolved:
+            final_metrics[metric] = per_metric_resolved[metric]
+        else:
+            # No agreement AND no adjudication — fall back to tie so downstream
+            # doesn't crash. This should not happen in practice since cascade
+            # routes any unresolved metric to adjudication.
+            final_metrics[metric] = "tie"
+
+    # Re-run the OP cascade against post-adjudication final_metrics.
+    # This is the authoritative source of op_value_or_null / op_source /
+    # needs_overall_manual downstream — cascade's pre-adjudication values
+    # are placeholders when the cascade-driving metrics were disputed.
+    op_value_or_null, op_source, needs_overall_manual = _recompute_cascade(final_metrics)
+
+    return {
+        "final_metrics": final_metrics,
+        "resolution_method": "adjudication" if ran_adjudication else "agreement",
+        "annotator_id_adjudicator": adjudicator_id if ran_adjudication else None,
+        "op_value_or_null": op_value_or_null,
+        "op_source": op_source,
+        "needs_overall_manual": needs_overall_manual,
+    }`,
+  },
+});

package/examples/video-pair-rating/nodes/merge_op_adjudication/node.ts

@@ -0,0 +1,51 @@
+import { code } from "@toloka-platform/sdk";
+import {
+  opNeedsAdjudication,
+  opManualValue,
+  opAdjudicatedValue,
+  finalOpValue,
+  finalOpResolutionMethod,
+  finalOpAdjudicatorId,
+} from "../../fields";
+
+export const mergeOpAdjudication = code("merge_op_adjudication", {
+  about: {
+    name: "merge_op_adjudication",
+    description:
+      "Consolidates the overall preference branch: if adjudication ran, emit the adjudicator pick and resolution_method=adjudication; otherwise emit the quorum majority and resolution_method=agreement.",
+  },
+  envVars: [],
+  fieldProxies: {
+    input: [
+      { field: opNeedsAdjudication, optional: false },
+      { field: opManualValue, optional: true },
+      { field: opAdjudicatedValue, optional: true },
+    ],
+    output: [
+      { field: finalOpValue, optional: false },
+      { field: finalOpResolutionMethod, optional: false },
+      { field: finalOpAdjudicatorId, optional: false },
+    ],
+  },
+  code: {
+    code: `from main_types import Inputs, Outputs
+
+
+async def main(inputs: Inputs) -> Outputs:
+    needs_adj = inputs.get("op_needs_adjudication", "false") == "true"
+    if needs_adj:
+        return {
+            "final_op_value": inputs["op_adjudicated_value"],
+            "final_op_resolution_method": "adjudication",
+            # Platform limitation (mirrors annotator_id_1/2 in assemble): the
+            # OP adjudicator id is not surfaced as a field proxy from the
+            # generation_sft node in this pilot. Emit null.
+            "final_op_adjudicator_id": None,
+        }
+    return {
+        "final_op_value": inputs["op_manual_value"],
+        "final_op_resolution_method": "agreement",
+        "final_op_adjudicator_id": None,
+    }`,
+  },
+});

package/examples/video-pair-rating/nodes/op_quorum_resolve/node.ts

@@ -0,0 +1,86 @@
+import { code } from "@toloka-platform/sdk";
+import {
+  prompt,
+  videoA,
+  videoB,
+  swap,
+  overallManualVotes,
+  opManualValue,
+  opNeedsAdjudication,
+  disagreedOpTask,
+  raterOpVotes,
+} from "../../fields";
+
+export const opQuorumResolve = code("op_quorum_resolve", {
+  about: {
+    name: "op_quorum_resolve",
+    description:
+      "Resolves three overall preference votes from the quorum into a majority. If fewer than two votes agree, flags for adjudication and packages the disagreed task payload.",
+  },
+  envVars: [],
+  fieldProxies: {
+    input: [
+      { field: prompt, optional: false },
+      { field: videoA, optional: false },
+      { field: videoB, optional: false },
+      { field: swap, optional: false },
+      { field: overallManualVotes, optional: false },
+    ],
+    output: [
+      { field: opManualValue, optional: true },
+      { field: opNeedsAdjudication, optional: false },
+      { field: disagreedOpTask, optional: false },
+      { field: raterOpVotes, optional: false },
+    ],
+  },
+  code: {
+    code: `from main_types import Inputs, Outputs
+
+
+async def main(inputs: Inputs) -> Outputs:
+    prompt = inputs["prompt"]
+    video_a = inputs["video_a"]
+    video_b = inputs["video_b"]
+    # \`overall_manual_votes\` is the quorum-collected array of 3 picks. The
+    # overall_preference_pick node shows videos in the original orientation
+    # (video_a/video_b, not video_1/video_2), so picks are already un-swapped.
+    votes = list(inputs.get("overall_manual_votes") or [])
+
+    counts = {}
+    for v in votes:
+        counts[v] = counts.get(v, 0) + 1
+    n = len(votes)
+    threshold = (n // 2) + 1
+    winner = None
+    for opt, c in counts.items():
+        if c >= threshold:
+            winner = opt
+            break
+
+    if winner is not None:
+        return {
+            "op_manual_value": winner,
+            "op_needs_adjudication": "false",
+            "disagreed_op_task": {
+                "prompt": prompt,
+                "video_a": video_a,
+                "video_b": video_b,
+                "votes": votes,
+            },
+            # Round C: forward un-swapped OP votes for QA reporting.
+            "rater_op_votes": votes,
+        }
+
+    return {
+        "op_manual_value": None,
+        "op_needs_adjudication": "true",
+        "disagreed_op_task": {
+            "prompt": prompt,
+            "video_a": video_a,
+            "video_b": video_b,
+            "votes": votes,
+        },
+        "rater_op_votes": votes,
+    }`,
+  },
+});

package/examples/video-pair-rating/nodes/overall_preference_pick/node.ts

@@ -0,0 +1,143 @@
+import { quorum } from "@toloka-platform/sdk";
+
+import { overallManualVotes, prompt, videoA, videoB } from "../../fields";
+
+export const overallPreferencePick = quorum("overall_preference_pick", {
+  about: { name: "overall_preference_pick" },
+  publicName: "Overall video preference",
+  overlap: 2,
+  entities: {
+    input: [
+      {
+        field: prompt,
+        entityType: "PROMPT",
+        description: "The text prompt both videos were generated from.",
+      },
+      {
+        field: videoA,
+        entityType: "VIDEO",
+        description:
+          "First generated video, in original order. This node deliberately does not use the shuffled pair.",
+      },
+      {
+        field: videoB,
+        entityType: "VIDEO",
+        description: "Second generated video, in original order.",
+      },
+    ],
+    output: [
+      {
+        field: overallManualVotes,
+        entityType: "SINGLE_LABEL",
+        jsonPath: "$.overall_manual_votes",
+        description: "One overall preference per rater, collected as an array.",
+      },
+    ],
+  },
+  qualityCriteria: [
+    {
+      id: "f5c72b91-4a08-4d63-95e7-3b1c8de046af",
+      qualityElement: "Whole-video judgment",
+      thresholds: {
+        pass: "The pick reflects the video as a finished result rather than one isolated strength or defect.",
+        fail: "The pick follows a single metric, or tie is used to avoid deciding.",
+      },
+      targetEntity: overallManualVotes,
+    },
+  ],
+  instruction:
+    "Watch both videos in full, then pick the one you would ship. This is a single judgment about the whole video, not a sum of its parts. Use tie only when you genuinely have no preference. Unlike the metric rating task, this one shows the pair in its original order, so your pick needs no un-shuffling downstream.",
+  ui: {
+    code: "<Field.SelectGroup path={'overall_manual_votes'} options={[{ label: 'First video', value: 'video_a' }, { label: 'Second video', value: 'video_b' }, { label: 'Tie', value: 'tie' }]} />",
+    data: '{"prompt":"a red fox crossing a snowy field at dawn","video_a":"https://example.com/video-a.mp4","video_b":"https://example.com/video-b.mp4"}',
+    preprocess: "return {}",
+    postprocess: "return {};",
+    constants: "{}",
+  },
+  onboarding: {
+    enabled: true,
+    steps: [
+      {
+        id: "step-1",
+        blocks: [
+          {
+            id: "block-1",
+            type: "text",
+            content: [
+              {
+                type: "markdown",
+                value:
+                  "You will pick which of two generated videos is better overall. Other raters score individual metrics; your task is the single whole-video judgment.",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "step-2",
+        blocks: [
+          {
+            id: "block-2",
+            type: "text",
+            content: [
+              {
+                type: "markdown",
+                value:
+                  "Overall preference is not the sum of metric wins. A video can be technically weaker in one respect and still be the one worth shipping. Reserve tie for real indifference.",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "step-3",
+        blocks: [
+          {
+            id: "block-3",
+            type: "quiz",
+            questions: [
+              {
+                id: "question-1",
+                type: "single-choice",
+                question:
+                  "One video is slightly grainier but tells the prompt clearly end to end. The other is pristine for two seconds and then falls apart. Which is preferred overall?",
+                options: [
+                  { value: "video_a", label: "The grainier one that holds together" },
+                  {
+                    value: "video_b",
+                    label: "The pristine one, because its best frames are better",
+                  },
+                  { value: "tie", label: "Tie, because each is better somewhere" },
+                ],
+                correctAnswer: "video_a",
+                correctAnswerFeedback:
+                  "Correct. A result that holds together beats one with a better peak and a broken ending.",
+                incorrectAnswerFeedback:
+                  "Judge the video as a finished result. A few excellent frames do not outweigh a collapse.",
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    info: {
+      estimatedTime: "2 minutes",
+      role: "Video rater",
+      goal: "Choose the better of two generated videos overall",
+      successCriteria: "A whole-video preference, with tie reserved for genuine indifference",
+    },
+  },
+  audienceAndPricing: {
+    audienceType: "human",
+    verifiedExperts: true,
+    audience: {
+      languages: { type: "and", values: [{ value: "English" }] },
+      specializations: { type: "and", values: [] },
+      countries: { type: "or", values: [] },
+    },
+    pricePerTask: 0.2,
+    timeForTask: 120,
+    perExpertCapEnabled: false,
+    perExpertCapValue: 1,
+  },
+});

package/examples/video-pair-rating/nodes/rate_pair/node.ts

@@ -0,0 +1,188 @@
+import { quorum } from "@toloka-platform/sdk";
+
+import {
+  imageQuality,
+  imageTextAlignment,
+  leftVideo,
+  motionQuality,
+  motionTextAlignment,
+  prompt,
+  rightVideo,
+  subjectBackgroundConsistency,
+  videoRealism,
+} from "../../fields";
+
+export const ratePair = quorum("rate_pair", {
+  about: { name: "rate_pair" },
+  publicName: "Side-by-side video rating",
+  overlap: 2,
+  entities: {
+    input: [
+      {
+        field: prompt,
+        entityType: "PROMPT",
+        description: "The text prompt both videos were generated from.",
+      },
+      {
+        field: leftVideo,
+        entityType: "VIDEO",
+        description: "The video shown on the left, in shuffled order.",
+      },
+      {
+        field: rightVideo,
+        entityType: "VIDEO",
+        description: "The video shown on the right, in shuffled order.",
+      },
+    ],
+    output: [
+      {
+        field: imageTextAlignment,
+        entityType: "SINGLE_LABEL",
+        jsonPath: "$.image_text_alignment",
+        description: "Which video matches the prompt in its imagery. One element per rater.",
+      },
+      {
+        field: motionTextAlignment,
+        entityType: "SINGLE_LABEL",
+        jsonPath: "$.motion_text_alignment",
+        description: "Which video matches the prompt in its motion. One element per rater.",
+      },
+      {
+        field: imageQuality,
+        entityType: "SINGLE_LABEL",
+        jsonPath: "$.image_quality",
+        description: "Which video looks better frame by frame. One element per rater.",
+      },
+      {
+        field: motionQuality,
+        entityType: "SINGLE_LABEL",
+        jsonPath: "$.motion_quality",
+        description: "Which video moves more plausibly. One element per rater.",
+      },
+      {
+        field: subjectBackgroundConsistency,
+        entityType: "SINGLE_LABEL",
+        jsonPath: "$.subject_background_consistency",
+        description: "Which video keeps its subject and background stable. One element per rater.",
+      },
+      {
+        field: videoRealism,
+        entityType: "SINGLE_LABEL",
+        jsonPath: "$.video_realism",
+        description: "Which video reads as more real. One element per rater.",
+      },
+    ],
+  },
+  qualityCriteria: [
+    {
+      id: "a4d81f26-3c95-4e07-b1da-6f2e8c5307b9",
+      qualityElement: "Metric independence",
+      thresholds: {
+        pass: "Each metric is scored on its own evidence, so a rater can prefer one video on imagery and the other on motion.",
+        fail: "Every metric receives the same pick, revealing a single overall impression applied across the board.",
+      },
+      targetEntity: imageQuality,
+    },
+    {
+      id: "d0b3e58a-71c4-42f9-9e6b-8a35c1704f2d",
+      qualityElement: "Prompt grounding",
+      thresholds: {
+        pass: "Alignment picks cite what the prompt actually asks for.",
+        fail: "Alignment is judged on general attractiveness rather than the prompt.",
+      },
+      targetEntity: imageTextAlignment,
+    },
+  ],
+  instruction:
+    "Watch both videos in full before answering. For each metric, pick the video that is better on that metric alone, or tie when they are equal. The two videos are presented in random order, so left and right carry no meaning. Different metrics can have different winners; that is expected.",
+  ui: {
+    code: "<View.Group><Field.SelectGroup path={'image_text_alignment'} label={'Which video matches the prompt in its imagery?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'motion_text_alignment'} label={'Which video matches the prompt in its motion?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'image_quality'} label={'Which video looks better frame by frame?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'motion_quality'} label={'Which video moves more plausibly?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'subject_background_consistency'} label={'Which video keeps its subject and background stable?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'video_realism'} label={'Which video reads as more real?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /></View.Group>",
+    data: '{"prompt":"a red fox crossing a snowy field at dawn","left_video":"https://example.com/video-left.mp4","right_video":"https://example.com/video-right.mp4"}',
+    preprocess: "return {}",
+    postprocess: "return {};",
+    constants: "{}",
+  },
+  onboarding: {
+    enabled: true,
+    steps: [
+      {
+        id: "step-1",
+        blocks: [
+          {
+            id: "block-1",
+            type: "text",
+            content: [
+              {
+                type: "markdown",
+                value:
+                  "You will compare two short generated videos made from the same prompt, and score them on several separate quality metrics.",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "step-2",
+        blocks: [
+          {
+            id: "block-2",
+            type: "text",
+            content: [
+              {
+                type: "markdown",
+                value:
+                  "Each metric is its own question. Imagery alignment asks whether what is shown matches the prompt. Motion quality asks whether movement is plausible. A video can win one and lose the other. Left and right are randomized, so position tells you nothing.",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "step-3",
+        blocks: [
+          {
+            id: "block-3",
+            type: "quiz",
+            questions: [
+              {
+                id: "question-1",
+                type: "single-choice",
+                question:
+                  "The prompt asks for a fox in snow. The left video shows a crisp fox on grass; the right shows a slightly blurry fox in snow. Which wins imagery alignment?",
+                options: [
+                  { value: "video_1", label: "Left, because it is crisper" },
+                  { value: "video_2", label: "Right, because it shows what the prompt asked for" },
+                  { value: "tie", label: "Tie, because both show a fox" },
+                ],
+                correctAnswer: "video_2",
+                correctAnswerFeedback:
+                  "Correct. Alignment is about matching the prompt; sharpness belongs to image quality.",
+                incorrectAnswerFeedback:
+                  "Alignment measures whether the video shows what the prompt asked for. Judge sharpness under image quality instead.",
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    info: {
+      estimatedTime: "3 minutes",
+      role: "Video rater",
+      goal: "Score a pair of generated videos across several quality metrics",
+      successCriteria: "Each metric scored independently, with ties used only for genuine equality",
+    },
+  },
+  audienceAndPricing: {
+    audienceType: "human",
+    verifiedExperts: true,
+    audience: {
+      languages: { type: "and", values: [{ value: "English" }] },
+      specializations: { type: "and", values: [] },
+      countries: { type: "or", values: [] },
+    },
+    pricePerTask: 0.2,
+    timeForTask: 120,
+    perExpertCapEnabled: false,
+    perExpertCapValue: 1,
+  },
+});

package/examples/video-pair-rating/nodes/root/node.ts

@@ -0,0 +1,7 @@
+import { root } from "@toloka-platform/sdk";
+import * as f from "../../fields";
+
+export const collection = root({
+  started: [f.prompt, f.videoA, f.videoB],
+  completed: [f.deliveryRecord],
+});