Upload 201 files

pairs/pair_0/input.txt

@@ -0,0 +1,4 @@
+#
+# Copyright (C) 2023, Inria
+# GRAPHDECO research group, https://team.inria.fr/graphdeco
+# Al

pairs/pair_0/output.txt

@@ -0,0 +1,7 @@
+l rights reserved.
+#
+# This software is free for non-commercial, research and evaluation use
+# under the terms of the LICENSE.md file.
+#
+# For inquiries contact  [email protected]
+#

pairs/pair_1/input.txt

@@ -0,0 +1,18 @@
+#
+# Copyright (C) 2023, Inria
+# GRAPHDECO research group, https://team.inria.fr/graphdeco
+# All rights reserved.
+#
+# This software is free for non-commercial, research and evaluation use 
+# under the terms of the LICENSE.md file.
+#
+# For inquiries contact  [email protected]
+#
+
+import torch
+from torch import nn
+import numpy as np
+from utils.graphics_utils import getWorld2View2, getProjectionMatrix
+
+class Camera(nn.Module):
+    def __init__(self, colmap_id, R

pairs/pair_1/output.txt

@@ -0,0 +1,13 @@
+, T, FoVx, FoVy, image, gt_alpha_mask,
+                 image_name, uid,
+                 trans=np.array([0.0, 0.0, 0.0]), scale=1.0, data_device = "cuda"
+                 ):
+        super(Camera, self).__init__()
+
+        self.uid = uid
+        self.colmap_id = colmap_id
+        self.R = R
+        self.T = T
+        self.FoVx = FoVx
+        self.FoVy = FoVy
+        self.image_name = image_name

pairs/pair_10/input.txt

@@ -0,0 +1,178 @@
+         if "wsgi.input_terminated" in request.environ:
+                app.logger.debug(
+                    "environ wsgi.input_terminated already set, keeping: %s"
+                    % request.environ["wsgi.input_terminated"]
+                )
+            else:
+                request.environ["wsgi.input_terminated"] = 1
+        else:
+            abort(501, "Chunked requests are not supported for server %s" % server)
+
+
+@app.after_request
+def set_cors_headers(response):
+    response.headers["Access-Control-Allow-Origin"] = request.headers.get("Origin", "*")
+    response.headers["Access-Control-Allow-Credentials"] = "true"
+
+    if request.method == "OPTIONS":
+        # Both of these headers are only used for the "preflight request"
+        # http://www.w3.org/TR/cors/#access-control-allow-methods-response-header
+        response.headers[
+            "Access-Control-Allow-Methods"
+        ] = "GET, POST, PUT, DELETE, PATCH, OPTIONS"
+        response.headers["Access-Control-Max-Age"] = "3600"  # 1 hour cache
+        if request.headers.get("Access-Control-Request-Headers") is not None:
+            response.headers["Access-Control-Allow-Headers"] = request.headers[
+                "Access-Control-Request-Headers"
+            ]
+    return response
+
+
+# ------
+# Routes
+# ------
+
+
+@app.route("/legacy")
+def view_landing_page():
+    """Generates Landing Page in legacy layout."""
+    return render_template("index.html")
+
+
+@app.route("/html")
+def view_html_page():
+    """Returns a simple HTML document.
+    ---
+    tags:
+      - Response formats
+    produces:
+      - text/html
+    responses:
+      200:
+        description: An HTML page.
+    """
+
+    return render_template("moby.html")
+
+
+@app.route("/robots.txt")
+def view_robots_page():
+    """Returns some robots.txt rules.
+    ---
+    tags:
+      - Response formats
+    produces:
+      - text/plain
+    responses:
+      200:
+        description: Robots file
+    """
+
+    response = make_response()
+    response.data = ROBOT_TXT
+    response.content_type = "text/plain"
+    return response
+
+
+@app.route("/deny")
+def view_deny_page():
+    """Returns page denied by robots.txt rules.
+    ---
+    tags:
+      - Response formats
+    produces:
+      - text/plain
+    responses:
+      200:
+        description: Denied message
+    """
+    response = make_response()
+    response.data = ANGRY_ASCII
+    response.content_type = "text/plain"
+    return response
+    # return "YOU SHOULDN'T BE HERE"
+
+
+@app.route("/ip")
+def view_origin():
+    """Returns the requester's IP Address.
+    ---
+    tags:
+      - Request inspection
+    produces:
+      - application/json
+    responses:
+      200:
+        description: The Requester's IP Address.
+    """
+
+    return jsonify(origin=request.headers.get("X-Forwarded-For", request.remote_addr))
+
+
+@app.route("/uuid")
+def view_uuid():
+    """Return a UUID4.
+    ---
+    tags:
+      - Dynamic data
+    produces:
+      - application/json
+    responses:
+      200:
+        description: A UUID4.
+    """
+
+    return jsonify(uuid=str(uuid.uuid4()))
+
+
+@app.route("/headers")
+def view_headers():
+    """Return the incoming request's HTTP headers.
+    ---
+    tags:
+      - Request inspection
+    produces:
+      - application/json
+    responses:
+      200:
+        description: The request's headers.
+    """
+
+    return jsonify(get_dict('headers'))
+
+
+@app.route("/user-agent")
+def view_user_agent():
+    """Return the incoming requests's User-Agent header.
+    ---
+    tags:
+      - Request inspection
+    produces:
+      - application/json
+    responses:
+      200:
+        description: The request's User-Agent header.
+    """
+
+    headers = get_headers()
+
+    return jsonify({"user-agent": headers["user-agent"]})
+
+
+@app.route("/get", methods=("GET",))
+def view_get():
+    """The request's query parameters.
+    ---
+    tags:
+      - HTTP Methods
+    produces:
+      - application/json
+    responses:
+      200:
+        description: The request's query parameters.
+    """
+
+    return jsonify(get_dict("url", "args", "headers", "origin"))
+
+
+@app.route("/anything", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "TRAC

pairs/pair_10/output.txt

@@ -0,0 +1 @@
+E"])

pairs/pair_11/input.txt

@@ -0,0 +1,379 @@
+ue) == 1:
+                value = value[0]
+            d[key] = value
+        response = jsonify(d)
+        for key, value in headers.items(multi=True):
+            response.headers.add(key, value)
+        response_has_changed = response.data != original_data
+        if not response_has_changed:
+            break
+    return response
+
+
+@app.route("/cookies")
+def view_cookies(hide_env=True):
+    """Returns cookie data.
+    ---
+    tags:
+      - Cookies
+    produces:
+      - application/json
+    responses:
+      200:
+        description: Set cookies.
+    """
+
+    cookies = dict(request.cookies.items())
+
+    if hide_env and ("show_env" not in request.args):
+        for key in ENV_COOKIES:
+            try:
+                del cookies[key]
+            except KeyError:
+                pass
+
+    return jsonify(cookies=cookies)
+
+
+@app.route("/forms/post")
+def view_forms_post():
+    """Simple HTML form."""
+
+    return render_template("forms-post.html")
+
+
+@app.route("/cookies/set/<name>/<value>")
+def set_cookie(name, value):
+    """Sets a cookie and redirects to cookie list.
+    ---
+    tags:
+      - Cookies
+    parameters:
+      - in: path
+        name: name
+        type: string
+      - in: path
+        name: value
+        type: string
+    produces:
+      - text/plain
+    responses:
+      200:
+        description: Set cookies and redirects to cookie list.
+    """
+
+    r = app.make_response(redirect(url_for("view_cookies")))
+    r.set_cookie(key=name, value=value, secure=secure_cookie())
+
+    return r
+
+
+@app.route("/cookies/set")
+def set_cookies():
+    """Sets cookie(s) as provided by the query string and redirects to cookie list.
+    ---
+    tags:
+      - Cookies
+    parameters:
+      - in: query
+        name: freeform
+        explode: true
+        allowEmptyValue: true
+        schema:
+          type: object
+          additionalProperties:
+            type: string
+        style: form
+    produces:
+      - text/plain
+    responses:
+      200:
+        description: Redirect to cookie list
+    """
+
+    cookies = dict(request.args.items())
+    r = app.make_response(redirect(url_for("view_cookies")))
+    for key, value in cookies.items():
+        r.set_cookie(key=key, value=value, secure=secure_cookie())
+
+    return r
+
+
+@app.route("/cookies/delete")
+def delete_cookies():
+    """Deletes cookie(s) as provided by the query string and redirects to cookie list.
+    ---
+    tags:
+      - Cookies
+    parameters:
+      - in: query
+        name: freeform
+        explode: true
+        allowEmptyValue: true
+        schema:
+          type: object
+          additionalProperties:
+            type: string
+        style: form
+    produces:
+      - text/plain
+    responses:
+      200:
+        description: Redirect to cookie list
+    """
+
+    cookies = dict(request.args.items())
+    r = app.make_response(redirect(url_for("view_cookies")))
+    for key, value in cookies.items():
+        r.delete_cookie(key=key)
+
+    return r
+
+
+@app.route("/basic-auth/<user>/<passwd>")
+def basic_auth(user="user", passwd="passwd"):
+    """Prompts the user for authorization using HTTP Basic Auth.
+    ---
+    tags:
+      - Auth
+    parameters:
+      - in: path
+        name: user
+        type: string
+      - in: path
+        name: passwd
+        type: string
+    produces:
+      - application/json
+    responses:
+      200:
+        description: Sucessful authentication.
+      401:
+        description: Unsuccessful authentication.
+    """
+
+    if not check_basic_auth(user, passwd):
+        return status_code(401)
+
+    return jsonify(authenticated=True, user=user)
+
+
+@app.route("/hidden-basic-auth/<user>/<passwd>")
+def hidden_basic_auth(user="user", passwd="passwd"):
+    """Prompts the user for authorization using HTTP Basic Auth.
+    ---
+    tags:
+      - Auth
+    parameters:
+      - in: path
+        name: user
+        type: string
+      - in: path
+        name: passwd
+        type: string
+    produces:
+      - application/json
+    responses:
+      200:
+        description: Sucessful authentication.
+      404:
+        description: Unsuccessful authentication.
+    """
+
+    if not check_basic_auth(user, passwd):
+        return status_code(404)
+    return jsonify(authenticated=True, user=user)
+
+
+@app.route("/bearer")
+def bearer_auth():
+    """Prompts the user for authorization using bearer authentication.
+    ---
+    tags:
+      - Auth
+    parameters:
+      - in: header
+        name: Authorization
+        schema:
+          type: string
+    produces:
+      - application/json
+    responses:
+      200:
+        description: Sucessful authentication.
+      401:
+        description: Unsuccessful authentication.
+    """
+    authorization = request.headers.get("Authorization")
+    if not (authorization and authorization.startswith("Bearer ")):
+        response = app.make_response("")
+        response.headers["WWW-Authenticate"] = "Bearer"
+        response.status_code = 401
+        return response
+    slice_start = len("Bearer ")
+    token = authorization[slice_start:]
+
+    return jsonify(authenticated=True, token=token)
+
+
+@app.route("/digest-auth/<qop>/<user>/<passwd>")
+def digest_auth_md5(qop=None, user="user", passwd="passwd"):
+    """Prompts the user for authorization using Digest Auth.
+    ---
+    tags:
+      - Auth
+    parameters:
+      - in: path
+        name: qop
+        type: string
+        description: auth or auth-int
+      - in: path
+        name: user
+        type: string
+      - in: path
+        name: passwd
+        type: string
+    produces:
+      - application/json
+    responses:
+      200:
+        description: Sucessful authentication.
+      401:
+        description: Unsuccessful authentication.
+    """
+    return digest_auth(qop, user, passwd, "MD5", "never")
+
+
+@app.route("/digest-auth/<qop>/<user>/<passwd>/<algorithm>")
+def digest_auth_nostale(qop=None, user="user", passwd="passwd", algorithm="MD5"):
+    """Prompts the user for authorization using Digest Auth + Algorithm.
+    ---
+    tags:
+      - Auth
+    parameters:
+      - in: path
+        name: qop
+        type: string
+        description: auth or auth-int
+      - in: path
+        name: user
+        type: string
+      - in: path
+        name: passwd
+        type: string
+      - in: path
+        name: algorithm
+        type: string
+        description: MD5, SHA-256, SHA-512
+        default: MD5
+    produces:
+      - application/json
+    responses:
+      200:
+        description: Sucessful authentication.
+      401:
+        description: Unsuccessful authentication.
+    """
+    return digest_auth(qop, user, passwd, algorithm, "never")
+
+
+@app.route("/digest-auth/<qop>/<user>/<passwd>/<algorithm>/<stale_after>")
+def digest_auth(
+    qop=None, user="user", passwd="passwd", algorithm="MD5", stale_after="never"
+):
+    """Prompts the user for authorization using Digest Auth + Algorithm.
+    allow settings the stale_after argument.
+    ---
+    tags:
+      - Auth
+    parameters:
+      - in: path
+        name: qop
+        type: string
+        description: auth or auth-int
+      - in: path
+        name: user
+        type: string
+      - in: path
+        name: passwd
+        type: string
+      - in: path
+        name: algorithm
+        type: string
+        description: MD5, SHA-256, SHA-512
+        default: MD5
+      - in: path
+        name: stale_after
+        type: string
+        default: never
+    produces:
+      - application/json
+    responses:
+      200:
+        description: Sucessful authentication.
+      401:
+        description: Unsuccessful authentication.
+    """
+    require_cookie_handling = request.args.get("require-cookie", "").lower() in (
+        "1",
+        "t",
+        "true",
+    )
+    if algorithm not in ("MD5", "SHA-256", "SHA-512"):
+        algorithm = "MD5"
+
+    if qop not in ("auth", "auth-int"):
+        qop = None
+
+    authorization = request.headers.get("Authorization")
+    credentials = None
+    if authorization:
+        credentials = parse_authorization_header(authorization)
+
+    if (
+        not authorization
+        or not credentials
+        or credentials.type.lower() != "digest"
+        or (require_cookie_handling and "Cookie" not in request.headers)
+    ):
+        response = digest_challenge_response(app, qop, algorithm)
+        response.set_cookie("stale_after", value=stale_after)
+        response.set_cookie("fake", value="fake_value")
+        return response
+
+    if require_cookie_handling and request.cookies.get("fake") != "fake_value":
+        response = jsonify({"errors": ["missing cookie set on challenge"]})
+        response.set_cookie("fake", value="fake_value")
+        response.status_code = 403
+        return response
+
+    current_nonce = credentials.get("nonce")
+
+    stale_after_value = None
+    if "stale_after" in request.cookies:
+        stale_after_value = request.cookies.get("stale_after")
+
+    if (
+        "last_nonce" in request.cookies
+        and current_nonce == request.cookies.get("last_nonce")
+        or stale_after_value == "0"
+    ):
+        response = digest_challenge_response(app, qop, algorithm, True)
+        response.set_cookie("stale_after", value=stale_after)
+        response.set_cookie("last_nonce", value=current_nonce)
+        response.set_cookie("fake", value="fake_value")
+        return response
+
+    if not check_digest_auth(user, passwd):
+        response = digest_challenge_response(app, qop, algorithm, False)
+        response.set_cookie("stale_after", value=stale_after)
+        response.set_cookie("last_nonce", value=current_nonce)
+        response.set_cookie("fake", value="fake_value")
+        return response
+
+    response = jsonify(authenticated=True, user=user)
+    response.set_cookie("fake", value="fake_value")
+    if stale_after_value:
+        response.set_cookie(
+            "stale_after", value=next_stale_after_value(stale_after_value)
+ 

pairs/pair_11/output.txt

@@ -0,0 +1,3 @@
+       )
+
+    return response

pairs/pair_12/input.txt

@@ -0,0 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numbers
+from math import cos, pi
+
+import annotator.

pairs/pair_12/output.txt

@@ -0,0 +1 @@
+uniformer.mmcv as mmcv

pairs/pair_13/input.txt

@@ -0,0 +1,74 @@
+on
+            maps or list of prediction result filenames.
+        gt_seg_maps (list[ndarray] | list[str]): list of ground truth
+            segmentation maps or list of label filenames.
+        num_classes (int): Number of categories.
+        ignore_index (int): Index that will be ignored in evaluation.
+        nan_to_num (int, optional): If specified, NaN values will be replaced
+            by the numbers defined by the user. Default: None.
+        label_map (dict): Mapping old labels to new labels. Default: dict().
+        reduce_zero_label (bool): Wether ignore zero label. Default: False.
+        beta (int): Determines the weight of recall in the combined score.
+            Default: False.
+
+
+     Returns:
+        dict[str, float | ndarray]: Default metrics.
+            <aAcc> float: Overall accuracy on all images.
+            <Fscore> ndarray: Per category recall, shape (num_classes, ).
+            <Precision> ndarray: Per category precision, shape (num_classes, ).
+            <Recall> ndarray: Per category f-score, shape (num_classes, ).
+    """
+    fscore_result = eval_metrics(
+        results=results,
+        gt_seg_maps=gt_seg_maps,
+        num_classes=num_classes,
+        ignore_index=ignore_index,
+        metrics=['mFscore'],
+        nan_to_num=nan_to_num,
+        label_map=label_map,
+        reduce_zero_label=reduce_zero_label,
+        beta=beta)
+    return fscore_result
+
+
+def eval_metrics(results,
+                 gt_seg_maps,
+                 num_classes,
+                 ignore_index,
+                 metrics=['mIoU'],
+                 nan_to_num=None,
+                 label_map=dict(),
+                 reduce_zero_label=False,
+                 beta=1):
+    """Calculate evaluation metrics
+    Args:
+        results (list[ndarray] | list[str]): List of prediction segmentation
+            maps or list of prediction result filenames.
+        gt_seg_maps (list[ndarray] | list[str]): list of ground truth
+            segmentation maps or list of label filenames.
+        num_classes (int): Number of categories.
+        ignore_index (int): Index that will be ignored in evaluation.
+        metrics (list[str] | str): Metrics to be evaluated, 'mIoU' and 'mDice'.
+        nan_to_num (int, optional): If specified, NaN values will be replaced
+            by the numbers defined by the user. Default: None.
+        label_map (dict): Mapping old labels to new labels. Default: dict().
+        reduce_zero_label (bool): Wether ignore zero label. Default: False.
+     Returns:
+        float: Overall accuracy on all images.
+        ndarray: Per category accuracy, shape (num_classes, ).
+        ndarray: Per category evaluation metrics, shape (num_classes, ).
+    """
+    if isinstance(metrics, str):
+        metrics = [metrics]
+    allowed_metrics = ['mIoU', 'mDice', 'mFscore']
+    if not set(metrics).issubset(set(allowed_metrics)):
+        raise KeyError('metrics {} is not supported'.format(metrics))
+
+    total_area_intersect, total_area_union, total_area_pred_label, \
+        total_area_label = total_intersect_and_union(
+            results, gt_seg_maps, num_classes, ignore_index, label_map,
+            reduce_zero_label)
+    all_acc = total_area_intersect.sum() / total_area_label.sum()
+    ret_metrics = OrderedDict({'aAcc': all_acc})
+    for metri

pairs/pair_13/output.txt

@@ -0,0 +1,31 @@
+c in metrics:
+        if metric == 'mIoU':
+            iou = total_area_intersect / total_area_union
+            acc = total_area_intersect / total_area_label
+            ret_metrics['IoU'] = iou
+            ret_metrics['Acc'] = acc
+        elif metric == 'mDice':
+            dice = 2 * total_area_intersect / (
+                total_area_pred_label + total_area_label)
+            acc = total_area_intersect / total_area_label
+            ret_metrics['Dice'] = dice
+            ret_metrics['Acc'] = acc
+        elif metric == 'mFscore':
+            precision = total_area_intersect / total_area_pred_label
+            recall = total_area_intersect / total_area_label
+            f_value = torch.tensor(
+                [f_score(x[0], x[1], beta) for x in zip(precision, recall)])
+            ret_metrics['Fscore'] = f_value
+            ret_metrics['Precision'] = precision
+            ret_metrics['Recall'] = recall
+
+    ret_metrics = {
+        metric: value.numpy()
+        for metric, value in ret_metrics.items()
+    }
+    if nan_to_num is not None:
+        ret_metrics = OrderedDict({
+            metric: np.nan_to_num(metric_value, nan=nan_to_num)
+            for metric, metric_value in ret_metrics.items()
+        })
+    return ret_metrics

pairs/pair_14/input.txt

@@ -0,0 +1,155 @@
+x_t = (
+                    expand_dims(sigma_t / sigma_s, dims) * x
+                    - expand_dims(alpha_t * phi_1, dims) * model_s
+            )
+            if return_intermediate:
+                return x_t, {'model_s': model_s}
+            else:
+                return x_t
+        else:
+            phi_1 = torch.expm1(h)
+            if model_s is None:
+                model_s = self.model_fn(x, s)
+            x_t = (
+                    expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
+                    - expand_dims(sigma_t * phi_1, dims) * model_s
+            )
+            if return_intermediate:
+                return x_t, {'model_s': model_s}
+            else:
+                return x_t
+
+    def singlestep_dpm_solver_second_update(self, x, s, t, r1=0.5, model_s=None, return_intermediate=False,
+                                            solver_type='dpm_solver'):
+        """
+        Singlestep solver DPM-Solver-2 from time `s` to time `t`.
+        Args:
+            x: A pytorch tensor. The initial value at time `s`.
+            s: A pytorch tensor. The starting time, with the shape (x.shape[0],).
+            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
+            r1: A `float`. The hyperparameter of the second-order solver.
+            model_s: A pytorch tensor. The model function evaluated at time `s`.
+                If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it.
+            return_intermediate: A `bool`. If true, also return the model value at time `s` and `s1` (the intermediate time).
+            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
+                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
+        Returns:
+            x_t: A pytorch tensor. The approximated solution at time `t`.
+        """
+        if solver_type not in ['dpm_solver', 'taylor']:
+            raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type))
+        if r1 is None:
+            r1 = 0.5
+        ns = self.noise_schedule
+        dims = x.dim()
+        lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t)
+        h = lambda_t - lambda_s
+        lambda_s1 = lambda_s + r1 * h
+        s1 = ns.inverse_lambda(lambda_s1)
+        log_alpha_s, log_alpha_s1, log_alpha_t = ns.marginal_log_mean_coeff(s), ns.marginal_log_mean_coeff(
+            s1), ns.marginal_log_mean_coeff(t)
+        sigma_s, sigma_s1, sigma_t = ns.marginal_std(s), ns.marginal_std(s1), ns.marginal_std(t)
+        alpha_s1, alpha_t = torch.exp(log_alpha_s1), torch.exp(log_alpha_t)
+
+        if self.predict_x0:
+            phi_11 = torch.expm1(-r1 * h)
+            phi_1 = torch.expm1(-h)
+
+            if model_s is None:
+                model_s = self.model_fn(x, s)
+            x_s1 = (
+                    expand_dims(sigma_s1 / sigma_s, dims) * x
+                    - expand_dims(alpha_s1 * phi_11, dims) * model_s
+            )
+            model_s1 = self.model_fn(x_s1, s1)
+            if solver_type == 'dpm_solver':
+                x_t = (
+                        expand_dims(sigma_t / sigma_s, dims) * x
+                        - expand_dims(alpha_t * phi_1, dims) * model_s
+                        - (0.5 / r1) * expand_dims(alpha_t * phi_1, dims) * (model_s1 - model_s)
+                )
+            elif solver_type == 'taylor':
+                x_t = (
+                        expand_dims(sigma_t / sigma_s, dims) * x
+                        - expand_dims(alpha_t * phi_1, dims) * model_s
+                        + (1. / r1) * expand_dims(alpha_t * ((torch.exp(-h) - 1.) / h + 1.), dims) * (
+                                    model_s1 - model_s)
+                )
+        else:
+            phi_11 = torch.expm1(r1 * h)
+            phi_1 = torch.expm1(h)
+
+            if model_s is None:
+                model_s = self.model_fn(x, s)
+            x_s1 = (
+                    expand_dims(torch.exp(log_alpha_s1 - log_alpha_s), dims) * x
+                    - expand_dims(sigma_s1 * phi_11, dims) * model_s
+            )
+            model_s1 = self.model_fn(x_s1, s1)
+            if solver_type == 'dpm_solver':
+                x_t = (
+                        expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
+                        - expand_dims(sigma_t * phi_1, dims) * model_s
+                        - (0.5 / r1) * expand_dims(sigma_t * phi_1, dims) * (model_s1 - model_s)
+                )
+            elif solver_type == 'taylor':
+                x_t = (
+                        expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
+                        - expand_dims(sigma_t * phi_1, dims) * model_s
+                        - (1. / r1) * expand_dims(sigma_t * ((torch.exp(h) - 1.) / h - 1.), dims) * (model_s1 - model_s)
+                )
+        if return_intermediate:
+            return x_t, {'model_s': model_s, 'model_s1': model_s1}
+        else:
+            return x_t
+
+    def singlestep_dpm_solver_third_update(self, x, s, t, r1=1. / 3., r2=2. / 3., model_s=None, model_s1=None,
+                                           return_intermediate=False, solver_type='dpm_solver'):
+        """
+        Singlestep solver DPM-Solver-3 from time `s` to time `t`.
+        Args:
+            x: A pytorch tensor. The initial value at time `s`.
+            s: A pytorch tensor. The starting time, with the shape (x.shape[0],).
+            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
+            r1: A `float`. The hyperparameter of the third-order solver.
+            r2: A `float`. The hyperparameter of the third-order solver.
+            model_s: A pytorch tensor. The model function evaluated at time `s`.
+                If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it.
+            model_s1: A pytorch tensor. The model function evaluated at time `s1` (the intermediate time given by `r1`).
+                If `model_s1` is None, we evaluate the model at `s1`; otherwise we directly use it.
+            return_intermediate: A `bool`. If true, also return the model value at time `s`, `s1` and `s2` (the intermediate times).
+            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
+                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
+        Returns:
+            x_t: A pytorch tensor. The approximated solution at time `t`.
+        """
+        if solver_type not in ['dpm_solver', 'taylor']:
+            raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type))
+        if r1 is None:
+            r1 = 1. / 3.
+        if r2 is None:
+            r2 = 2. / 3.
+        ns = self.noise_schedule
+        dims = x.dim()
+        lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t)
+        h = lambda_t - lambda_s
+        lambda_s1 = lambda_s + r1 * h
+        lambda_s2 = lambda_s + r2 * h
+        s1 = ns.inverse_lambda(lambda_s1)
+        s2 = ns.inverse_lambda(lambda_s2)
+        log_alpha_s, log_alpha_s1, log_alpha_s2, log_alpha_t = ns.marginal_log_mean_coeff(
+            s), ns.marginal_log_mean_coeff(s1), ns.marginal_log_mean_coeff(s2), ns.marginal_log_mean_coeff(t)
+        sigma_s, sigma_s1, sigma_s2, sigma_t = ns.marginal_std(s), ns.marginal_std(s1), ns.marginal_std(
+            s2), ns.marginal_std(t)
+        alpha_s1, alpha_s2, alpha_t = torch.exp(log_alpha_s1), torch.exp(log_alpha_s2), torch.exp(log_alpha_t)
+
+        if self.predict_x0:
+            phi_11 = torch.expm1(-r1 * h)
+            phi_12 = torch.expm1(-r2 * h)
+            phi_1 = torch.expm1(-h)
+            phi_22 = torch.expm1(-r2 * h) / (r2 * h) + 1.
+            phi_2 = phi_1 / h + 1.
+            phi_3 = phi_2 / h - 0.5
+
+            if model_s is None:
+                model_s = self.mode

pairs/pair_14/output.txt

@@ -0,0 +1,30 @@
+l_fn(x, s)
+            if model_s1 is None:
+                x_s1 = (
+                        expand_dims(sigma_s1 / sigma_s, dims) * x
+                        - expand_dims(alpha_s1 * phi_11, dims) * model_s
+                )
+                model_s1 = self.model_fn(x_s1, s1)
+            x_s2 = (
+                    expand_dims(sigma_s2 / sigma_s, dims) * x
+                    - expand_dims(alpha_s2 * phi_12, dims) * model_s
+                    + r2 / r1 * expand_dims(alpha_s2 * phi_22, dims) * (model_s1 - model_s)
+            )
+            model_s2 = self.model_fn(x_s2, s2)
+            if solver_type == 'dpm_solver':
+                x_t = (
+                        expand_dims(sigma_t / sigma_s, dims) * x
+                        - expand_dims(alpha_t * phi_1, dims) * model_s
+                        + (1. / r2) * expand_dims(alpha_t * phi_2, dims) * (model_s2 - model_s)
+                )
+            elif solver_type == 'taylor':
+                D1_0 = (1. / r1) * (model_s1 - model_s)
+                D1_1 = (1. / r2) * (model_s2 - model_s)
+                D1 = (r2 * D1_0 - r1 * D1_1) / (r2 - r1)
+                D2 = 2. * (D1_1 - D1_0) / (r2 - r1)
+                x_t = (
+                        expand_dims(sigma_t / sigma_s, dims) * x
+                        - expand_dims(alpha_t * phi_1, dims) * model_s
+                        + expand_dims(alpha_t * phi_2, dims) * D1
+                        - expand_dims(alpha_t * phi_3, dims) * D2
+                )

pairs/pair_15/input.txt

@@ -0,0 +1,81 @@
+     cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(xc, t, context=cc)
+        elif self.conditioning_key == 'hybrid-adm':
+            assert c_adm is not None
+            xc = torch.cat([x] + c_concat, dim=1)
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(xc, t, context=cc, y=c_adm)
+        elif self.conditioning_key == 'crossattn-adm':
+            assert c_adm is not None
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(x, t, context=cc, y=c_adm)
+        elif self.conditioning_key == 'adm':
+            cc = c_crossattn[0]
+            out = self.diffusion_model(x, t, y=cc)
+        else:
+            raise NotImplementedError()
+
+        return out
+
+
+class LatentUpscaleDiffusion(LatentDiffusion):
+    def __init__(self, *args, low_scale_config, low_scale_key="LR", noise_level_key=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        # assumes that neither the cond_stage nor the low_scale_model contain trainable params
+        assert not self.cond_stage_trainable
+        self.instantiate_low_stage(low_scale_config)
+        self.low_scale_key = low_scale_key
+        self.noise_level_key = noise_level_key
+
+    def instantiate_low_stage(self, config):
+        model = instantiate_from_config(config)
+        self.low_scale_model = model.eval()
+        self.low_scale_model.train = disabled_train
+        for param in self.low_scale_model.parameters():
+            param.requires_grad = False
+
+    @torch.no_grad()
+    def get_input(self, batch, k, cond_key=None, bs=None, log_mode=False):
+        if not log_mode:
+            z, c = super().get_input(batch, k, force_c_encode=True, bs=bs)
+        else:
+            z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True,
+                                                  force_c_encode=True, return_original_cond=True, bs=bs)
+        x_low = batch[self.low_scale_key][:bs]
+        x_low = rearrange(x_low, 'b h w c -> b c h w')
+        x_low = x_low.to(memory_format=torch.contiguous_format).float()
+        zx, noise_level = self.low_scale_model(x_low)
+        if self.noise_level_key is not None:
+            # get noise level from batch instead, e.g. when extracting a custom noise level for bsr
+            raise NotImplementedError('TODO')
+
+        all_conds = {"c_concat": [zx], "c_crossattn": [c], "c_adm": noise_level}
+        if log_mode:
+            # TODO: maybe disable if too expensive
+            x_low_rec = self.low_scale_model.decode(zx)
+            return z, all_conds, x, xrec, xc, x_low, x_low_rec, noise_level
+        return z, all_conds
+
+    @torch.no_grad()
+    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
+                   plot_denoise_rows=False, plot_progressive_rows=True, plot_diffusion_rows=True,
+                   unconditional_guidance_scale=1., unconditional_guidance_label=None, use_ema_scope=True,
+                   **kwargs):
+        ema_scope = self.ema_scope if use_ema_scope else nullcontext
+        use_ddim = ddim_steps is not None
+
+        log = dict()
+        z, c, x, xrec, xc, x_low, x_low_rec, noise_level = self.get_input(batch, self.first_stage_key, bs=N,
+                                                                          log_mode=True)
+        N = min(x.shape[0], N)
+        n_row = min(x.shape[0], n_row)
+        log["inputs"] = x
+        log["reconstruction"] = xrec
+        log["x_lr"] = x_low
+        log[f"x_lr_rec_@noise_levels{'-'.join(map(lambda x: str(x), list(noise_level.cpu().numpy())))}"] = x_low_rec
+        if self.model.conditioning_key is not None:
+            if hasattr(self.cond_stage_model, "decode"):
+                xc = self.cond_stage_model.decode(c)
+                log["conditioning"] = xc
+            elif self.cond_stage_key in ["caption", "txt"]:
+                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[

pairs/pair_15/output.txt

@@ -0,0 +1,9 @@
+2] // 25)
+                log["conditioning"] = xc
+            elif self.cond_stage_key in ['class_label', 'cls']:
+                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25)
+                log['conditioning'] = xc
+            elif isimage(xc):
+                log["conditioning"] = xc
+            if ismap(xc):
+                log["original_conditioning"] = self.to_rgb(xc)

pairs/pair_16/input.txt

@@ -0,0 +1,43 @@
+import numpy as np
+from keras.models import *
+from keras.layers import *
+from keras.applications.vgg16 import VGG16
+from keras.preprocessing.image import ImageDataGenerator
+from keras.optimizers import *
+from keras.callbacks import ModelCheckpoint
+import cv2
+
+def train_generator(batch_size=32):
+    data_gen_args = dict(featurewise_center=True,
+                         rotation_range=90.,
+                         width_shift_range=0.1,
+                         height_shift_range=0.1,
+                         fill_mode="constant",
+                         cval=255,
+                         horizontal_flip=True,
+                         vertical_flip=True,
+                         zoom_range=0.2)
+    image_datagen = ImageDataGenerator(**data_gen_args)
+    mask_datagen = ImageDataGenerator(**data_gen_args)
+
+    seed = 1
+    image_generator = image_datagen.flow_from_directory(
+        'data/train/images',
+        class_mode=None,
+        batch_size=batch_size,
+        color_mode='rgb',
+        target_size=(512,512),
+        #save_to_dir='./data/gen/images',
+        seed=seed)
+
+    mask_generator = mask_datagen.flow_from_directory(
+        'data/train/masks',
+        class_mode=None,
+        color_mode='grayscale',
+        target_size=(512,512),
+        batch_size=batch_size,
+        #save_to_dir='./data/gen/masks',
+        seed=seed)
+
+    # combine generators into one which yields image and masks
+    train_generator = zip(image_generator, mask_

pairs/pair_16/output.txt

@@ -0,0 +1,5 @@
+generator)
+    for (imgs, masks) in train_generator:
+        imgs = imgs / 255.0
+        masks = masks / 255.0
+        yield (imgs,masks)

pairs/pair_17/input.txt

@@ -0,0 +1,82 @@
+import numpy as np
+from keras.models import *
+from keras.layers import *
+from keras.applications.vgg16 import VGG16
+from keras.preprocessing.image import ImageDataGenerator
+from keras.optimizers import *
+from keras.callbacks import ModelCheckpoint
+import cv2
+
+def train_generator(batch_size=32):
+    data_gen_args = dict(featurewise_center=True,
+                         rotation_range=90.,
+                         width_shift_range=0.1,
+                         height_shift_range=0.1,
+                         fill_mode="constant",
+                         cval=255,
+                         horizontal_flip=True,
+                         vertical_flip=True,
+                         zoom_range=0.2)
+    image_datagen = ImageDataGenerator(**data_gen_args)
+    mask_datagen = ImageDataGenerator(**data_gen_args)
+
+    seed = 1
+    image_generator = image_datagen.flow_from_directory(
+        'data/train/images',
+        class_mode=None,
+        batch_size=batch_size,
+        color_mode='rgb',
+        target_size=(512,512),
+        #save_to_dir='./data/gen/images',
+        seed=seed)
+
+    mask_generator = mask_datagen.flow_from_directory(
+        'data/train/masks',
+        class_mode=None,
+        color_mode='grayscale',
+        target_size=(512,512),
+        batch_size=batch_size,
+        #save_to_dir='./data/gen/masks',
+        seed=seed)
+
+    # combine generators into one which yields image and masks
+    train_generator = zip(image_generator, mask_generator)
+    for (imgs, masks) in train_generator:
+        imgs = imgs / 255.0
+        masks = masks / 255.0
+        yield (imgs,masks)
+
+
+def vgg10_unet(input_shape=(256,256,3), weights='imagenet'):
+    vgg16_model = VGG16(input_shape=input_shape, weights=weights, include_top=False)
+
+    block4_pool = vgg16_model.get_layer('block4_pool').output
+    block5_conv1 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block4_pool)
+    block5_conv2 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block5_conv1)
+    block5_drop = Dropout(0.5)(block5_conv2)
+
+    block6_up = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
+        UpSampling2D(size=(2, 2))(block5_drop))
+    block6_merge = Concatenate(axis=3)([vgg16_model.get_layer('block4_conv3').output, block6_up])
+    block6_conv1 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_merge)
+    block6_conv2 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_conv1)
+    block6_conv3 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_conv2)
+
+    block7_up = Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
+        UpSampling2D(size=(2, 2))(block6_conv3))
+    block7_merge = Concatenate(axis=3)([vgg16_model.get_layer('block3_conv3').output, block7_up])
+    block7_conv1 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_merge)
+    block7_conv2 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv1)
+    block7_conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv2)
+
+    block8_up = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
+        UpSampling2D(size=(2, 2))(block7_conv3))
+    block8_merge = Concatenate(axis=3)([vgg16_model.get_layer('block2_conv2').output, block8_up])
+    block8_conv1 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_merge)
+    block8_conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_conv1)
+
+    block9_up = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
+        UpSampling2D(size=(2, 2))(block8_conv2))
+    block9_merge = Concatenate(axis=3)([vgg16_model.get_layer('block1_conv2').output, block9_up])
+    block9_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_merge)
+    block9_conv2 = Conv2D(64, 3, activation='relu'

pairs/pair_17/output.txt

@@ -0,0 +1,7 @@
+, padding='same', kernel_initializer='he_normal')(block9_conv1)
+
+    block10_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_conv2)
+    block10_conv2 = Conv2D(1, 1, activation='sigmoid')(block10_conv1)
+
+    model = Model(inputs=vgg16_model.input, outputs=block10_conv2)
+    return model

pairs/pair_18/input.txt

@@ -0,0 +1,24 @@
+import numpy as np
+from keras.models import *
+from keras.layers import *
+from keras.applications.vgg16 import VGG16
+from keras.preprocessing.image import ImageDataGenerator
+from keras.optimizers import *
+from keras.callbacks import ModelCheckpoint
+import cv2
+
+def train_generator(batch_size=32):
+    data_gen_args = dict(featurewise_center=True,
+                         rotation_range=90.,
+                         width_shift_range=0.1,
+                         height_shift_range=0.1,
+                         fill_mode="constant",
+                         cval=255,
+                         horizontal_flip=True,
+                         vertical_flip=True,
+                         zoom_range=0.2)
+    image_datagen = ImageDataGenerator(**data_gen_args)
+    mask_datagen = ImageDataGenerator(**data_gen_args)
+
+    seed = 1
+    image_generator = image_datagen.flow_fr

pairs/pair_18/output.txt

@@ -0,0 +1,8 @@
+om_directory(
+        'data/train/images',
+        class_mode=None,
+        batch_size=batch_size,
+        color_mode='rgb',
+        target_size=(512,512),
+        #save_to_dir='./data/gen/images',
+        seed=seed)

pairs/pair_19/input.txt

@@ -0,0 +1,37 @@
+er('block3_conv3').output, block7_up])
+    block7_conv1 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_merge)
+    block7_conv2 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv1)
+    block7_conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv2)
+
+    block8_up = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
+        UpSampling2D(size=(2, 2))(block7_conv3))
+    block8_merge = Concatenate(axis=3)([vgg16_model.get_layer('block2_conv2').output, block8_up])
+    block8_conv1 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_merge)
+    block8_conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_conv1)
+
+    block9_up = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
+        UpSampling2D(size=(2, 2))(block8_conv2))
+    block9_merge = Concatenate(axis=3)([vgg16_model.get_layer('block1_conv2').output, block9_up])
+    block9_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_merge)
+    block9_conv2 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_conv1)
+
+    block10_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_conv2)
+    block10_conv2 = Conv2D(1, 1, activation='sigmoid')(block10_conv1)
+
+    model = Model(inputs=vgg16_model.input, outputs=block10_conv2)
+    return model
+
+
+if __name__ == '__main__':
+    is_train = False
+    if is_train:
+        model = vgg10_unet(input_shape=(512,512,3), weights='imagenet')
+
+        for index in range(15):
+            model.layers[index].trainable = True
+        model.compile(optimizer=Adam(lr=1e-4), loss='binary_crossentropy', metrics=['accuracy'])
+        model_checkpoint = ModelCheckpoint('unet.h5', monitor='loss', verbose=1, save_best_only=True)
+        model.fit_generator(train_generator(batch_size=4),
+                            steps_per_epoch=200,
+                            epochs=50,
+                            validation_data=train_generator(ba

pairs/pair_19/output.txt

@@ -0,0 +1,3 @@
+tch_size=4),
+                            validation_steps=50,
+                            callbacks=[model_checkpoint])

pairs/pair_2/input.txt

@@ -0,0 +1,42 @@
+     for idx, frame in enumerate(frames):
+            cam_name = os.path.join(path, frame["file_path"] + extension)
+
+            # NeRF 'transform_matrix' is a camera-to-world transform
+            c2w = np.array(frame["transform_matrix"])
+            # change from OpenGL/Blender camera axes (Y up, Z back) to COLMAP (Y down, Z forward)
+            c2w[:3, 1:3] *= -1
+
+            # get the world-to-camera transform and set R, T
+            w2c = np.linalg.inv(c2w)
+            R = np.transpose(w2c[:3,:3])  # R is stored transposed due to 'glm' in CUDA code
+            T = w2c[:3, 3]
+
+            image_path = os.path.join(path, cam_name)
+            image_name = Path(cam_name).stem
+            image = Image.open(image_path)
+
+            im_data = np.array(image.convert("RGBA"))
+
+            bg = np.array([1,1,1]) if white_background else np.array([0, 0, 0])
+
+            norm_data = im_data / 255.0
+            arr = norm_data[:,:,:3] * norm_data[:, :, 3:4] + bg * (1 - norm_data[:, :, 3:4])
+            image = Image.fromarray(np.array(arr*255.0, dtype=np.byte), "RGB")
+
+            fovy = focal2fov(fov2focal(fovx, image.size[0]), image.size[1])
+            FovY = fovy 
+            FovX = fovx
+
+            cam_infos.append(CameraInfo(uid=idx, R=R, T=T, FovY=FovY, FovX=FovX, image=image,
+                            image_path=image_path, image_name=image_name, width=image.size[0], height=image.size[1]))
+            
+    return cam_infos
+
+def readNerfSyntheticInfo(path, white_background, eval, extension=".png"):
+    print("Reading Training Transforms")
+    train_cam_infos = readCamerasFromTransforms(path, "transforms_train.json", white_background, extension)
+    print("Reading Test Transforms")
+    test_cam_infos = readCamerasFromTransforms(path, "transforms_test.json", white_background, extension)
+    
+    if not eval:
+        train_cam_infos.extend(test_cam_info

pairs/pair_2/output.txt

@@ -0,0 +1,33 @@
+s)
+        test_cam_infos = []
+
+    nerf_normalization = getNerfppNorm(train_cam_infos)
+
+    ply_path = os.path.join(path, "points3d.ply")
+    if not os.path.exists(ply_path):
+        # Since this data set has no colmap data, we start with random points
+        num_pts = 100_000
+        print(f"Generating random point cloud ({num_pts})...")
+        
+        # We create random points inside the bounds of the synthetic Blender scenes
+        xyz = np.random.random((num_pts, 3)) * 2.6 - 1.3
+        shs = np.random.random((num_pts, 3)) / 255.0
+        pcd = BasicPointCloud(points=xyz, colors=SH2RGB(shs), normals=np.zeros((num_pts, 3)))
+
+        storePly(ply_path, xyz, SH2RGB(shs) * 255)
+    try:
+        pcd = fetchPly(ply_path)
+    except:
+        pcd = None
+
+    scene_info = SceneInfo(point_cloud=pcd,
+                           train_cameras=train_cam_infos,
+                           test_cameras=test_cam_infos,
+                           nerf_normalization=nerf_normalization,
+                           ply_path=ply_path)
+    return scene_info
+
+sceneLoadTypeCallbacks = {
+    "Colmap": readColmapSceneInfo,
+    "Blender" : readNerfSyntheticInfo
+}

pairs/pair_20/input.txt

@@ -0,0 +1,317 @@
+     [0, 1, 2, 3, 4, 5, 6],
+                    ]
+
+    @classmethod
+    def Colors(cls):
+        """Returns the list of colors.
+        """
+        return cls.colors
+
+    @classmethod
+    def ColorGenerator(cls, n):
+        """Returns an iterator of color strings.
+
+        n: how many colors will be used
+        """
+        for i in cls.which_colors[n]:
+            yield cls.colors[i]
+        raise StopIteration('Ran out of colors in _Brewer.ColorGenerator')
+
+    @classmethod
+    def InitializeIter(cls, num):
+        """Initializes the color iterator with the given number of colors."""
+        cls.color_iter = cls.ColorGenerator(num)
+
+    @classmethod
+    def ClearIter(cls):
+        """Sets the color iterator to None."""
+        cls.color_iter = None
+
+    @classmethod
+    def GetIter(cls):
+        """Gets the color iterator."""
+        if cls.color_iter is None:
+            cls.InitializeIter(7)
+
+        return cls.color_iter
+
+
+def PrePlot(num=None, rows=None, cols=None):
+    """Takes hints about what's coming.
+
+    num: number of lines that will be plotted
+    rows: number of rows of subplots
+    cols: number of columns of subplots
+    """
+    if num:
+        _Brewer.InitializeIter(num)
+
+    if rows is None and cols is None:
+        return
+
+    if rows is not None and cols is None:
+        cols = 1
+
+    if cols is not None and rows is None:
+        rows = 1
+
+    # resize the image, depending on the number of rows and cols
+    size_map = {(1, 1): (8, 6),
+                (1, 2): (14, 6),
+                (1, 3): (14, 6),
+                (2, 2): (10, 10),
+                (2, 3): (16, 10),
+                (3, 1): (8, 10),
+                }
+
+    if (rows, cols) in size_map:
+        fig = pyplot.gcf()
+        fig.set_size_inches(*size_map[rows, cols])
+
+    # create the first subplot
+    if rows > 1 or cols > 1:
+        pyplot.subplot(rows, cols, 1)
+        global SUBPLOT_ROWS, SUBPLOT_COLS
+        SUBPLOT_ROWS = rows
+        SUBPLOT_COLS = cols
+
+
+def SubPlot(plot_number, rows=None, cols=None):
+    """Configures the number of subplots and changes the current plot.
+
+    rows: int
+    cols: int
+    plot_number: int
+    """
+    rows = rows or SUBPLOT_ROWS
+    cols = cols or SUBPLOT_COLS
+    pyplot.subplot(rows, cols, plot_number)
+
+
+def _Underride(d, **options):
+    """Add key-value pairs to d only if key is not in d.
+
+    If d is None, create a new dictionary.
+
+    d: dictionary
+    options: keyword args to add to d
+    """
+    if d is None:
+        d = {}
+
+    for key, val in options.items():
+        d.setdefault(key, val)
+
+    return d
+
+
+def Clf():
+    """Clears the figure and any hints that have been set."""
+    global LOC
+    LOC = None
+    _Brewer.ClearIter()
+    pyplot.clf()
+    fig = pyplot.gcf()
+    fig.set_size_inches(8, 6)
+
+
+def Figure(**options):
+    """Sets options for the current figure."""
+    _Underride(options, figsize=(6, 8))
+    pyplot.figure(**options)
+
+
+def _UnderrideColor(options):
+    if 'color' in options:
+        return options
+
+    color_iter = _Brewer.GetIter()
+
+    if color_iter:
+        try:
+            options['color'] = next(color_iter)
+        except StopIteration:
+            # TODO: reconsider whether this should warn
+            # warnings.warn('Warning: Brewer ran out of colors.')
+            _Brewer.ClearIter()
+    return options
+
+
+def Plot(obj, ys=None, style='', **options):
+    """Plots a line.
+
+    Args:
+      obj: sequence of x values, or Series, or anything with Render()
+      ys: sequence of y values
+      style: style string passed along to pyplot.plot
+      options: keyword args passed to pyplot.plot
+    """
+    options = _UnderrideColor(options)
+    label = getattr(obj, 'label', '_nolegend_')
+    options = _Underride(options, linewidth=3, alpha=0.8, label=label)
+
+    xs = obj
+    if ys is None:
+        if hasattr(obj, 'Render'):
+            xs, ys = obj.Render()
+        if isinstance(obj, pandas.Series):
+            ys = obj.values
+            xs = obj.index
+
+    if ys is None:
+        pyplot.plot(xs, style, **options)
+    else:
+        pyplot.plot(xs, ys, style, **options)
+
+
+def FillBetween(xs, y1, y2=None, where=None, **options):
+    """Plots a line.
+
+    Args:
+      xs: sequence of x values
+      y1: sequence of y values
+      y2: sequence of y values
+      where: sequence of boolean
+      options: keyword args passed to pyplot.fill_between
+    """
+    options = _UnderrideColor(options)
+    options = _Underride(options, linewidth=0, alpha=0.5)
+    pyplot.fill_between(xs, y1, y2, where, **options)
+
+
+def Bar(xs, ys, **options):
+    """Plots a line.
+
+    Args:
+      xs: sequence of x values
+      ys: sequence of y values
+      options: keyword args passed to pyplot.bar
+    """
+    options = _UnderrideColor(options)
+    options = _Underride(options, linewidth=0, alpha=0.6)
+    pyplot.bar(xs, ys, **options)
+
+
+def Scatter(xs, ys=None, **options):
+    """Makes a scatter plot.
+
+    xs: x values
+    ys: y values
+    options: options passed to pyplot.scatter
+    """
+    options = _Underride(options, color='blue', alpha=0.2, 
+                        s=30, edgecolors='none')
+
+    if ys is None and isinstance(xs, pandas.Series):
+        ys = xs.values
+        xs = xs.index
+
+    pyplot.scatter(xs, ys, **options)
+
+
+def HexBin(xs, ys, **options):
+    """Makes a scatter plot.
+
+    xs: x values
+    ys: y values
+    options: options passed to pyplot.scatter
+    """
+    options = _Underride(options, cmap=matplotlib.cm.Blues)
+    pyplot.hexbin(xs, ys, **options)
+
+
+def Pdf(pdf, **options):
+    """Plots a Pdf, Pmf, or Hist as a line.
+
+    Args:
+      pdf: Pdf, Pmf, or Hist object
+      options: keyword args passed to pyplot.plot
+    """
+    low, high = options.pop('low', None), options.pop('high', None)
+    n = options.pop('n', 101)
+    xs, ps = pdf.Render(low=low, high=high, n=n)
+    options = _Underride(options, label=pdf.label)
+    Plot(xs, ps, **options)
+
+
+def Pdfs(pdfs, **options):
+    """Plots a sequence of PDFs.
+
+    Options are passed along for all PDFs.  If you want different
+    options for each pdf, make multiple calls to Pdf.
+    
+    Args:
+      pdfs: sequence of PDF objects
+      options: keyword args passed to pyplot.plot
+    """
+    for pdf in pdfs:
+        Pdf(pdf, **options)
+
+
+def Hist(hist, **options):
+    """Plots a Pmf or Hist with a bar plot.
+
+    The default width of the bars is based on the minimum difference
+    between values in the Hist.  If that's too small, you can override
+    it by providing a width keyword argument, in the same units
+    as the values.
+
+    Args:
+      hist: Hist or Pmf object
+      options: keyword args passed to pyplot.bar
+    """
+    # find the minimum distance between adjacent values
+    xs, ys = hist.Render()
+
+    if 'width' not in options:
+        try:
+            options['width'] = 0.9 * np.diff(xs).min()
+        except TypeError:
+            warnings.warn("Hist: Can't compute bar width automatically."
+                            "Check for non-numeric types in Hist."
+                            "Or try providing width option."
+                            )
+
+    options = _Underride(options, label=hist.label)
+    options = _Underride(options, align='center')
+    if options['align'] == 'left':
+        options['align'] = 'edge'
+    elif options['align'] == 'right':
+        options['align'] = 'edge'
+        options['width'] *= -1
+
+    Bar(xs, ys, **options)
+
+
+def Hists(hists, **options):
+    """Plots two histograms as interleaved bar plots.
+
+    Options are passed along for all PMFs.  If you want different
+    options for each pmf, make multiple calls to Pmf.
+
+    Args:
+      hists: list of two Hist or Pmf objects
+      options: keyword args passed to pyplot.plot
+    """
+    for hist in hists:
+        Hist(hist, **options)
+
+
+def Pmf(pmf, **options):
+    """Plots a Pmf or Hist as a line.
+
+    Args:
+      pmf: Hist or Pmf object
+      options: keyword args passed to pyplot.plot
+    """
+    xs, ys = pmf.Render()
+    low, high = min(xs), max(xs)
+
+    width = options.pop('width', None)
+    if width is None:
+        try:
+            width = np.diff(xs).min()
+        except TypeError:
+            warnings.warn("Pmf: Can't compute bar width automatically."
+                          "Check for non-numeric types in Pmf."
+                         

pairs/pair_20/output.txt

@@ -0,0 +1 @@
+ "Or try providing width option.")

pairs/pair_21/input.txt

@@ -0,0 +1,50 @@
+m most common place
+if len(train_df.Embarked[ train_df.Embarked.isnull() ]) > 0:
+    train_df.Embarked[ train_df.Embarked.isnull() ] = train_df.Embarked.dropna().mode().values
+
+Ports = list(enumerate(np.unique(train_df['Embarked'])))    # determine all values of Embarked,
+Ports_dict = { name : i for i, name in Ports }              # set up a dictionary in the form  Ports : index
+train_df.Embarked = train_df.Embarked.map( lambda x: Ports_dict[x]).astype(int)     # Convert all Embark strings to int
+
+# All the ages with no data -> make the median of all Ages
+median_age = train_df['Age'].dropna().median()
+if len(train_df.Age[ train_df.Age.isnull() ]) > 0:
+    train_df.loc[ (train_df.Age.isnull()), 'Age'] = median_age
+
+# Remove the Name column, Cabin, Ticket, and Sex (since I copied and filled it to Gender)
+train_df = train_df.drop(['Name', 'Sex', 'Ticket', 'Cabin', 'PassengerId'], axis=1) 
+
+
+# TEST DATA
+test_df = pd.read_csv('test.csv', header=0)        # Load the test file into a dataframe
+
+# I need to do the same with the test data now, so that the columns are the same as the training data
+# I need to convert all strings to integer classifiers:
+# female = 0, Male = 1
+test_df['Gender'] = test_df['Sex'].map( {'female': 0, 'male': 1} ).astype(int)
+
+# Embarked from 'C', 'Q', 'S'
+# All missing Embarked -> just make them embark from most common place
+if len(test_df.Embarked[ test_df.Embarked.isnull() ]) > 0:
+    test_df.Embarked[ test_df.Embarked.isnull() ] = test_df.Embarked.dropna().mode().values
+# Again convert all Embarked strings to int
+test_df.Embarked = test_df.Embarked.map( lambda x: Ports_dict[x]).astype(int)
+
+
+# All the ages with no data -> make the median of all Ages
+median_age = test_df['Age'].dropna().median()
+if len(test_df.Age[ test_df.Age.isnull() ]) > 0:
+    test_df.loc[ (test_df.Age.isnull()), 'Age'] = median_age
+
+# All the missing Fares -> assume median of their respective class
+if len(test_df.Fare[ test_df.Fare.isnull() ]) > 0:
+    median_fare = np.zeros(3)
+    for f in range(0,3):                                              # loop 0 to 2
+        median_fare[f] = test_df[ test_df.Pclass == f+1 ]['Fare'].dropna().median()
+    for f in range(0,3):                                              # loop 0 to 2
+        test_df.loc[ (test_df.Fare.isnull()) & (test_df.Pclass == f+1 ), 'Fare'] = median_fare[f]
+
+# Collect the test data's PassengerIds before dropping it
+ids = test_df['PassengerId'].values
+# Remove the Name column, Cabin, Ticket, and Sex (since I copied and filled it to Gender)
+test_df = test_df.drop(['Name', 'Sex', 'Ticket', 'Cabin', 'Passen

pairs/pair_21/output.txt

@@ -0,0 +1 @@
+gerId'], axis=1)

pairs/pair_22/input.txt

@@ -0,0 +1,75 @@
+xs, n=None):
+    """Draw a sample from xs with the same length as xs.
+
+    xs: sequence
+    n: sample size (default: len(xs))
+
+    returns: NumPy array
+    """
+    if n is None:
+        n = len(xs)
+    return np.random.choice(xs, n, replace=True)
+
+
+def SampleRows(df, nrows, replace=False):
+    """Choose a sample of rows from a DataFrame.
+
+    df: DataFrame
+    nrows: number of rows
+    replace: whether to sample with replacement
+
+    returns: DataDf
+    """
+    indices = np.random.choice(df.index, nrows, replace=replace)
+    sample = df.loc[indices]
+    return sample
+
+
+def ResampleRows(df):
+    """Resamples rows from a DataFrame.
+
+    df: DataFrame
+
+    returns: DataFrame
+    """
+    return SampleRows(df, len(df), replace=True)
+
+
+def ResampleRowsWeighted(df, column='finalwgt'):
+    """Resamples a DataFrame using probabilities proportional to given column.
+
+    df: DataFrame
+    column: string column name to use as weights
+
+    returns: DataFrame
+    """
+    weights = df[column]
+    cdf = Cdf(dict(weights))
+    indices = cdf.Sample(len(weights))
+    sample = df.loc[indices]
+    return sample
+
+
+def PercentileRow(array, p):
+    """Selects the row from a sorted array that maps to percentile p.
+
+    p: float 0--100
+
+    returns: NumPy array (one row)
+    """
+    rows, cols = array.shape
+    index = int(rows * p / 100)
+    return array[index,]
+
+
+def PercentileRows(ys_seq, percents):
+    """Given a collection of lines, selects percentiles along vertical axis.
+
+    For example, if ys_seq contains simulation results like ys as a
+    function of time, and percents contains (5, 95), the result would
+    be a 90% CI for each vertical slice of the simulation results.
+
+    ys_seq: sequence of lines (y values)
+    percents: list of percentiles (0-100) to select
+
+    returns: list of NumPy arrays, one for each pe

pairs/pair_22/output.txt

@@ -0,0 +1,13 @@
+rcentile
+    """
+    nrows = len(ys_seq)
+    ncols = len(ys_seq[0])
+    array = np.zeros((nrows, ncols))
+
+    for i, ys in enumerate(ys_seq):
+        array[i,] = ys
+
+    array = np.sort(array, axis=0)
+
+    rows = [PercentileRow(array, p) for p in percents]
+    return rows

pairs/pair_23/input.txt

@@ -0,0 +1,407 @@
+.
+
+        other: a number
+
+        returns: new Pmf
+        """
+        pmf = Pmf()
+        for v1, p1 in self.Items():
+            pmf.Set(v1 + other, p1)
+        return pmf
+
+    def __sub__(self, other):
+        """Computes the Pmf of the diff of values drawn from self and other.
+
+        other: another Pmf
+
+        returns: new Pmf
+        """
+        try:
+            return self.SubPmf(other)
+        except AttributeError:
+            return self.AddConstant(-other)
+
+    def SubPmf(self, other):
+        """Computes the Pmf of the diff of values drawn from self and other.
+
+        other: another Pmf
+
+        returns: new Pmf
+        """
+        pmf = Pmf()
+        for v1, p1 in self.Items():
+            for v2, p2 in other.Items():
+                pmf.Incr(v1 - v2, p1 * p2)
+        return pmf
+
+    def __mul__(self, other):
+        """Computes the Pmf of the product of values drawn from self and other.
+
+        other: another Pmf
+
+        returns: new Pmf
+        """
+        try:
+            return self.MulPmf(other)
+        except AttributeError:
+            return self.MulConstant(other)
+
+    def MulPmf(self, other):
+        """Computes the Pmf of the diff of values drawn from self and other.
+
+        other: another Pmf
+
+        returns: new Pmf
+        """
+        pmf = Pmf()
+        for v1, p1 in self.Items():
+            for v2, p2 in other.Items():
+                pmf.Incr(v1 * v2, p1 * p2)
+        return pmf
+
+    def MulConstant(self, other):
+        """Computes the Pmf of the product of a constant and values from self.
+
+        other: a number
+
+        returns: new Pmf
+        """
+        pmf = Pmf()
+        for v1, p1 in self.Items():
+            pmf.Set(v1 * other, p1)
+        return pmf
+
+    def __div__(self, other):
+        """Computes the Pmf of the ratio of values drawn from self and other.
+
+        other: another Pmf
+
+        returns: new Pmf
+        """
+        try:
+            return self.DivPmf(other)
+        except AttributeError:
+            return self.MulConstant(1/other)
+
+    __truediv__ = __div__
+
+    def DivPmf(self, other):
+        """Computes the Pmf of the ratio of values drawn from self and other.
+
+        other: another Pmf
+
+        returns: new Pmf
+        """
+        pmf = Pmf()
+        for v1, p1 in self.Items():
+            for v2, p2 in other.Items():
+                pmf.Incr(v1 / v2, p1 * p2)
+        return pmf
+
+    def Max(self, k):
+        """Computes the CDF of the maximum of k selections from this dist.
+
+        k: int
+
+        returns: new Cdf
+        """
+        cdf = self.MakeCdf()
+        return cdf.Max(k)
+
+
+class Joint(Pmf):
+    """Represents a joint distribution.
+
+    The values are sequences (usually tuples)
+    """
+
+    def Marginal(self, i, label=None):
+        """Gets the marginal distribution of the indicated variable.
+
+        i: index of the variable we want
+
+        Returns: Pmf
+        """
+        pmf = Pmf(label=label)
+        for vs, prob in self.Items():
+            pmf.Incr(vs[i], prob)
+        return pmf
+
+    def Conditional(self, i, j, val, label=None):
+        """Gets the conditional distribution of the indicated variable.
+
+        Distribution of vs[i], conditioned on vs[j] = val.
+
+        i: index of the variable we want
+        j: which variable is conditioned on
+        val: the value the jth variable has to have
+
+        Returns: Pmf
+        """
+        pmf = Pmf(label=label)
+        for vs, prob in self.Items():
+            if vs[j] != val:
+                continue
+            pmf.Incr(vs[i], prob)
+
+        pmf.Normalize()
+        return pmf
+
+    def MaxLikeInterval(self, percentage=90):
+        """Returns the maximum-likelihood credible interval.
+
+        If percentage=90, computes a 90% CI containing the values
+        with the highest likelihoods.
+
+        percentage: float between 0 and 100
+
+        Returns: list of values from the suite
+        """
+        interval = []
+        total = 0
+
+        t = [(prob, val) for val, prob in self.Items()]
+        t.sort(reverse=True)
+
+        for prob, val in t:
+            interval.append(val)
+            total += prob
+            if total >= percentage / 100.0:
+                break
+
+        return interval
+
+
+def MakeJoint(pmf1, pmf2):
+    """Joint distribution of values from pmf1 and pmf2.
+
+    Assumes that the PMFs represent independent random variables.
+
+    Args:
+        pmf1: Pmf object
+        pmf2: Pmf object
+
+    Returns:
+        Joint pmf of value pairs
+    """
+    joint = Joint()
+    for v1, p1 in pmf1.Items():
+        for v2, p2 in pmf2.Items():
+            joint.Set((v1, v2), p1 * p2)
+    return joint
+
+
+def MakeHistFromList(t, label=None):
+    """Makes a histogram from an unsorted sequence of values.
+
+    Args:
+        t: sequence of numbers
+        label: string label for this histogram
+
+    Returns:
+        Hist object
+    """
+    return Hist(t, label=label)
+
+
+def MakeHistFromDict(d, label=None):
+    """Makes a histogram from a map from values to frequencies.
+
+    Args:
+        d: dictionary that maps values to frequencies
+        label: string label for this histogram
+
+    Returns:
+        Hist object
+    """
+    return Hist(d, label)
+
+
+def MakePmfFromList(t, label=None):
+    """Makes a PMF from an unsorted sequence of values.
+
+    Args:
+        t: sequence of numbers
+        label: string label for this PMF
+
+    Returns:
+        Pmf object
+    """
+    return Pmf(t, label=label)
+
+
+def MakePmfFromDict(d, label=None):
+    """Makes a PMF from a map from values to probabilities.
+
+    Args:
+        d: dictionary that maps values to probabilities
+        label: string label for this PMF
+
+    Returns:
+        Pmf object
+    """
+    return Pmf(d, label=label)
+
+
+def MakePmfFromItems(t, label=None):
+    """Makes a PMF from a sequence of value-probability pairs
+
+    Args:
+        t: sequence of value-probability pairs
+        label: string label for this PMF
+
+    Returns:
+        Pmf object
+    """
+    return Pmf(dict(t), label=label)
+
+
+def MakePmfFromHist(hist, label=None):
+    """Makes a normalized PMF from a Hist object.
+
+    Args:
+        hist: Hist object
+        label: string label
+
+    Returns:
+        Pmf object
+    """
+    if label is None:
+        label = hist.label
+
+    return Pmf(hist, label=label)
+
+
+def MakeMixture(metapmf, label='mix'):
+    """Make a mixture distribution.
+
+    Args:
+      metapmf: Pmf that maps from Pmfs to probs.
+      label: string label for the new Pmf.
+
+    Returns: Pmf object.
+    """
+    mix = Pmf(label=label)
+    for pmf, p1 in metapmf.Items():
+        for x, p2 in pmf.Items():
+            mix.Incr(x, p1 * p2)
+    return mix
+
+
+def MakeUniformPmf(low, high, n):
+    """Make a uniform Pmf.
+
+    low: lowest value (inclusive)
+    high: highest value (inclusize)
+    n: number of values
+    """
+    pmf = Pmf()
+    for x in np.linspace(low, high, n):
+        pmf.Set(x, 1)
+    pmf.Normalize()
+    return pmf
+
+
+class Cdf(object):
+    """Represents a cumulative distribution function.
+
+    Attributes:
+        xs: sequence of values
+        ps: sequence of probabilities
+        label: string used as a graph label.
+    """
+    def __init__(self, obj=None, ps=None, label=None):
+        """Initializes.
+        
+        If ps is provided, obj must be the corresponding list of values.
+
+        obj: Hist, Pmf, Cdf, Pdf, dict, pandas Series, list of pairs
+        ps: list of cumulative probabilities
+        label: string label
+        """
+        self.label = label if label is not None else '_nolegend_'
+
+        if isinstance(obj, (_DictWrapper, Cdf, Pdf)):
+            if not label:
+                self.label = label if label is not None else obj.label
+
+        if obj is None:
+            # caller does not provide obj, make an empty Cdf
+            self.xs = np.asarray([])
+            self.ps = np.asarray([])
+            if ps is not None:
+                logging.warning("Cdf: can't pass ps without also passing xs.")
+            return
+        else:
+            # if the caller provides xs and ps, just store them          
+            if ps is not None:
+                if isinstance(ps, str):
+                    logging.warning("Cdf: ps can't be a string")
+
+                self.xs = np.asarray(obj)
+                self.ps = np.asarray(ps)
+                return
+
+        # caller has provided just obj, not ps
+        if isinstance(obj, Cdf):
+            self.xs = copy.copy(obj.xs)
+            self.ps = copy.copy(obj.ps)
+            return
+
+        if isinstance(obj, _DictWrapper):
+            dw = obj
+        else:
+            dw = Hist(obj)
+
+        if len(dw) == 0:
+            self.xs = np.asarray([])
+            self.ps = np.asarray([])
+            return
+
+        xs, freqs = zip(*sorted(dw.Items()))
+        self.xs = np.asarray(xs)
+        self.ps = np.cumsum(freqs, dtype=np.float)
+        self.ps /= self.ps[-1]
+
+    def __str__(self):
+        return 'Cdf(%s, %s)' % (str(self.xs), str(self.ps))
+
+    __repr__ = __str__
+
+    def __len__(self):
+        return len(self.xs)
+
+    def __getitem__(self, x):
+        return self.Prob(x)
+
+    def __setitem__(self):
+        raise UnimplementedMethodException()
+
+    def __delitem__(self):
+        raise UnimplementedMethodException()
+
+    def __eq__(self, other):
+        return np.all(self.xs == other.xs) and np.all(self.ps == other.ps)
+
+    def Copy(self, label=None):
+        """Returns a copy of this Cdf.
+
+        label: string label for the new Cdf
+        """
+        if label is None:
+            label = self.label
+        return Cdf(list(self.xs), list(self.ps), label=label)
+
+    def MakePmf(self, label=None):
+        """Makes a Pmf."""
+        if label is None:
+            label = self.label
+        return Pmf(self, label=label)
+
+    def Values(self):
+        """Returns a sorted list of values.
+        """
+        return self.xs
+
+    def Items(self):
+        """Returns a sorted sequence o

pairs/pair_23/output.txt

@@ -0,0 +1,8 @@
+f (value, probability) pairs.
+
+        Note: in Python3, returns an iterator.
+        """
+        a = self.ps
+        b = np.roll(a, 1)
+        b[0] = 0
+        return zip(self.xs, a-b)

pairs/pair_24/input.txt

@@ -0,0 +1,34 @@
+    except ModuleNotFoundError:
+        return False
+
+    return spec is not None
+
+
+def repo_dir(name):
+    return os.path.join(script_path, dir_repos, name)
+
+
+def run_pip(command, desc=None, live=default_command_live):
+    if args.skip_install:
+        return
+
+    index_url_line = f' --index-url {index_url}' if index_url != '' else ''
+    return run(f'"{python}" -m pip {command} --prefer-binary{index_url_line}', desc=f"Installing {desc}", errdesc=f"Couldn't install {desc}", live=live)
+
+
+def check_run_python(code: str) -> bool:
+    result = subprocess.run([python, "-c", code], capture_output=True, shell=False)
+    return result.returncode == 0
+
+
+def git_fix_workspace(dir, name):
+    run(f'"{git}" -C "{dir}" fetch --refetch --no-auto-gc', f"Fetching all contents for {name}", f"Couldn't fetch {name}", live=True)
+    run(f'"{git}" -C "{dir}" gc --aggressive --prune=now', f"Pruning {name}", f"Couldn't prune {name}", live=True)
+    return
+
+
+def run_git(dir, name, command, desc=None, errdesc=None, custom_env=None, live: bool = default_command_live, autofix=True):
+    try:
+        return run(f'"{git}" -C "{dir}" {command}', desc=desc, errdesc=errdesc, custom_env=custom_env, live=live)
+    except RuntimeError:
+        if not auto

pairs/pair_24/output.txt

@@ -0,0 +1,7 @@
+fix:
+            raise
+
+    print(f"{errdesc}, attempting autofix...")
+    git_fix_workspace(dir, name)
+
+    return run(f'"{git}" -C "{dir}" {command}', desc=desc, errdesc=errdesc, custom_env=custom_env, live=live)

pairs/pair_25/input.txt

@@ -0,0 +1,76 @@
+f infer_params(state_dict):
+    # this code is copied from https://github.com/victorca25/iNNfer
+    scale2x = 0
+    scalemin = 6
+    n_uplayer = 0
+    plus = False
+
+    for block in list(state_dict):
+        parts = block.split(".")
+        n_parts = len(parts)
+        if n_parts == 5 and parts[2] == "sub":
+            nb = int(parts[3])
+        elif n_parts == 3:
+            part_num = int(parts[1])
+            if (part_num > scalemin
+                and parts[0] == "model"
+                and parts[2] == "weight"):
+                scale2x += 1
+            if part_num > n_uplayer:
+                n_uplayer = part_num
+                out_nc = state_dict[block].shape[0]
+        if not plus and "conv1x1" in block:
+            plus = True
+
+    nf = state_dict["model.0.weight"].shape[0]
+    in_nc = state_dict["model.0.weight"].shape[1]
+    out_nc = out_nc
+    scale = 2 ** scale2x
+
+    return in_nc, out_nc, nf, nb, plus, scale
+
+
+class UpscalerESRGAN(Upscaler):
+    def __init__(self, dirname):
+        self.name = "ESRGAN"
+        self.model_url = "https://github.com/cszn/KAIR/releases/download/v1.0/ESRGAN.pth"
+        self.model_name = "ESRGAN_4x"
+        self.scalers = []
+        self.user_path = dirname
+        super().__init__()
+        model_paths = self.find_models(ext_filter=[".pt", ".pth"])
+        scalers = []
+        if len(model_paths) == 0:
+            scaler_data = UpscalerData(self.model_name, self.model_url, self, 4)
+            scalers.append(scaler_data)
+        for file in model_paths:
+            if file.startswith("http"):
+                name = self.model_name
+            else:
+                name = modelloader.friendly_name(file)
+
+            scaler_data = UpscalerData(name, file, self, 4)
+            self.scalers.append(scaler_data)
+
+    def do_upscale(self, img, selected_model):
+        try:
+            model = self.load_model(selected_model)
+        except Exception as e:
+            print(f"Unable to load ESRGAN model {selected_model}: {e}", file=sys.stderr)
+            return img
+        model.to(devices.device_esrgan)
+        img = esrgan_upscale(model, img)
+        return img
+
+    def load_model(self, path: str):
+        if path.startswith("http"):
+            # TODO: this doesn't use `path` at all?
+            filename = modelloader.load_file_from_url(
+                url=self.model_url,
+                model_dir=self.model_download_path,
+                file_name=f"{self.model_name}.pth",
+            )
+        else:
+            filename = path
+
+        state_

pairs/pair_25/output.txt

@@ -0,0 +1 @@
+dict = torch.load(filename, map_location='cpu' if devices.device_esrgan.type == 'mps' else None)

pairs/pair_26/input.txt

@@ -0,0 +1,104 @@
+elf.all_negative_prompts]
+
+        self.main_prompt = self.all_prompts[0]
+        self.main_negative_prompt = self.all_negative_prompts[0]
+
+    def cached_params(self, required_prompts, steps, extra_network_data, hires_steps=None, use_old_scheduling=False):
+        """Returns parameters that invalidate the cond cache if changed"""
+
+        return (
+            required_prompts,
+            steps,
+            hires_steps,
+            use_old_scheduling,
+            opts.CLIP_stop_at_last_layers,
+            shared.sd_model.sd_checkpoint_info,
+            extra_network_data,
+            opts.sdxl_crop_left,
+            opts.sdxl_crop_top,
+            self.width,
+            self.height,
+        )
+
+    def get_conds_with_caching(self, function, required_prompts, steps, caches, extra_network_data, hires_steps=None):
+        """
+        Returns the result of calling function(shared.sd_model, required_prompts, steps)
+        using a cache to store the result if the same arguments have been used before.
+
+        cache is an array containing two elements. The first element is a tuple
+        representing the previously used arguments, or None if no arguments
+        have been used before. The second element is where the previously
+        computed result is stored.
+
+        caches is a list with items described above.
+        """
+
+        if shared.opts.use_old_scheduling:
+            old_schedules = prompt_parser.get_learned_conditioning_prompt_schedules(required_prompts, steps, hires_steps, False)
+            new_schedules = prompt_parser.get_learned_conditioning_prompt_schedules(required_prompts, steps, hires_steps, True)
+            if old_schedules != new_schedules:
+                self.extra_generation_params["Old prompt editing timelines"] = True
+
+        cached_params = self.cached_params(required_prompts, steps, extra_network_data, hires_steps, shared.opts.use_old_scheduling)
+
+        for cache in caches:
+            if cache[0] is not None and cached_params == cache[0]:
+                return cache[1]
+
+        cache = caches[0]
+
+        with devices.autocast():
+            cache[1] = function(shared.sd_model, required_prompts, steps, hires_steps, shared.opts.use_old_scheduling)
+
+        cache[0] = cached_params
+        return cache[1]
+
+    def setup_conds(self):
+        prompts = prompt_parser.SdConditioning(self.prompts, width=self.width, height=self.height)
+        negative_prompts = prompt_parser.SdConditioning(self.negative_prompts, width=self.width, height=self.height, is_negative_prompt=True)
+
+        sampler_config = sd_samplers.find_sampler_config(self.sampler_name)
+        total_steps = sampler_config.total_steps(self.steps) if sampler_config else self.steps
+        self.step_multiplier = total_steps // self.steps
+        self.firstpass_steps = total_steps
+
+        self.uc = self.get_conds_with_caching(prompt_parser.get_learned_conditioning, negative_prompts, total_steps, [self.cached_uc], self.extra_network_data)
+        self.c = self.get_conds_with_caching(prompt_parser.get_multicond_learned_conditioning, prompts, total_steps, [self.cached_c], self.extra_network_data)
+
+    def get_conds(self):
+        return self.c, self.uc
+
+    def parse_extra_network_prompts(self):
+        self.prompts, self.extra_network_data = extra_networks.parse_prompts(self.prompts)
+
+    def save_samples(self) -> bool:
+        """Returns whether generated images need to be written to disk"""
+        return opts.samples_save and not self.do_not_save_samples and (opts.save_incomplete_images or not state.interrupted and not state.skipped)
+
+
+class Processed:
+    def __init__(self, p: StableDiffusionProcessing, images_list, seed=-1, info="", subseed=None, all_prompts=None, all_negative_prompts=None, all_seeds=None, all_subseeds=None, index_of_first_image=0, infotexts=None, comments=""):
+        self.images = images_list
+        self.prompt = p.prompt
+        self.negative_prompt = p.negative_prompt
+        self.seed = seed
+        self.subseed = subseed
+        self.subseed_strength = p.subseed_strength
+        self.info = info
+        self.comments = "".join(f"{comment}\n" for comment in p.comments)
+        self.width = p.width
+        self.height = p.height
+        self.sampler_name = p.sampler_name
+        self.cfg_scale = p.cfg_scale
+        self.image_cfg_scale = getattr(p, 'image_cfg_scale', None)
+        self.steps = p.steps
+        self.batch_size = p.batch_size
+        self.restore_faces = p.restore_faces
+        self.face_restoration_model = opts.face_restoration_model if p.restore_faces else None
+        self.sd_model_name = p.sd_model_name
+        self.sd_model_hash = p.sd_model_hash
+        self.sd_vae_name = p.sd_vae_name
+        self.sd_vae_hash = p.sd_vae_hash
+        self.seed_resize_from_w = p.seed_resize_from_w
+        self.seed_resize_from_h = p.seed_resize_from_h
+        self.den

pairs/pair_26/output.txt

@@ -0,0 +1,28 @@
+oising_strength = getattr(p, 'denoising_strength', None)
+        self.extra_generation_params = p.extra_generation_params
+        self.index_of_first_image = index_of_first_image
+        self.styles = p.styles
+        self.job_timestamp = state.job_timestamp
+        self.clip_skip = opts.CLIP_stop_at_last_layers
+        self.token_merging_ratio = p.token_merging_ratio
+        self.token_merging_ratio_hr = p.token_merging_ratio_hr
+
+        self.eta = p.eta
+        self.ddim_discretize = p.ddim_discretize
+        self.s_churn = p.s_churn
+        self.s_tmin = p.s_tmin
+        self.s_tmax = p.s_tmax
+        self.s_noise = p.s_noise
+        self.s_min_uncond = p.s_min_uncond
+        self.sampler_noise_scheduler_override = p.sampler_noise_scheduler_override
+        self.prompt = self.prompt if not isinstance(self.prompt, list) else self.prompt[0]
+        self.negative_prompt = self.negative_prompt if not isinstance(self.negative_prompt, list) else self.negative_prompt[0]
+        self.seed = int(self.seed if not isinstance(self.seed, list) else self.seed[0]) if self.seed is not None else -1
+        self.subseed = int(self.subseed if not isinstance(self.subseed, list) else self.subseed[0]) if self.subseed is not None else -1
+        self.is_using_inpainting_conditioning = p.is_using_inpainting_conditioning
+
+        self.all_prompts = all_prompts or p.all_prompts or [self.prompt]
+        self.all_negative_prompts = all_negative_prompts or p.all_negative_prompts or [self.negative_prompt]
+        self.all_seeds = all_seeds or p.all_seeds or [self.seed]
+        self.all_subseeds = all_subseeds or p.all_subseeds or [self.subseed]
+        self.infotexts = infotexts or [info]

pairs/pair_27/input.txt

@@ -0,0 +1,4 @@
+from __future__ import annotations
+import json
+import logging
+import math

pairs/pair_27/output.txt

@@ -0,0 +1,4 @@
+import os
+import sys
+import hashlib
+from dataclasses import dataclass, field

pairs/pair_28/input.txt

@@ -0,0 +1,35 @@
+# Reproductions/tests for crashes/read errors in TiffDecode.c
+
+# When run in Python, all of these images should fail for
+# one reason or another, either as a buffer overrun,
+# unrecognized datastream, or truncated image file.
+# There shouldn't be any segfaults.
+#
+# if run like
+# `valgrind --tool=memcheck pytest test_tiff_crashes.py 2>&1 | grep TiffDecode.c`
+# the output should be empty. There may be Python issues
+# in the valgrind especially if run in a debug Python
+# version.
+
+import pytest
+
+from PIL import Image
+
+from .helper import on_ci
+
+
+@pytest.mark.parametrize(
+    "test_file",
+    [
+        "Tests/images/crash_1.tif",
+        "Tests/images/crash_2.tif",
+        "Tests/images/crash-2020-10-test.tif",
+        "Tests/images/crash-0c7e0e8e11ce787078f00b5b0ca409a167f070e0.tif",
+        "Tests/images/crash-0e16d3bfb83be87356d026d66919deaefca44dac.tif",
+        "Tests/images/crash-1152ec2d1a1a71395b6f2ce6721c38924d025bf3.tif",
+        "Tests/images/crash-1185209cf7655b5aed8ae5e77784dfdd18ab59e9.tif",
+        "Tests/images/crash-338516dbd2f0e83caddb8ce256c22db3bd6dc40f.tif",
+        "Tests/images/crash-4f085cc12ece8cde18758d42608bed6a2a2cfb1c.tif",
+        "Tests/images/crash-86214e58da443d2b80820cff9677a38a33dcbbca.tif",
+        "Tests/images/crash-f46f5b2f43c370fe65706c11449f567ecc345e74.tif",
+        "T

pairs/pair_28/output.txt

@@ -0,0 +1,20 @@
+ests/images/crash-63b1dffefc8c075ddc606c0a2f5fdc15ece78863.tif",
+        "Tests/images/crash-74d2a78403a5a59db1fb0a2b8735ac068a75f6e3.tif",
+        "Tests/images/crash-81154a65438ba5aaeca73fd502fa4850fbde60f8.tif",
+        "Tests/images/crash-0da013a13571cc8eb457a39fee8db18f8a3c7127.tif",
+    ],
+)
+@pytest.mark.filterwarnings("ignore:Possibly corrupt EXIF data")
+@pytest.mark.filterwarnings("ignore:Metadata warning")
+@pytest.mark.filterwarnings("ignore:Truncated File Read")
+def test_tiff_crashes(test_file):
+    try:
+        with Image.open(test_file) as im:
+            im.load()
+    except FileNotFoundError:
+        if not on_ci():
+            pytest.skip("test image not found")
+            return
+        raise
+    except OSError:
+        pass

pairs/pair_29/input.txt

@@ -0,0 +1,263 @@
+ent"] = s
+    self.app["COM"] = s  # compatibility
+    self.applist.append(("COM", s))
+
+
+def SOF(self, marker):
+    #
+    # Start of frame marker.  Defines the size and mode of the
+    # image.  JPEG is colour blind, so we use some simple
+    # heuristics to map the number of layers to an appropriate
+    # mode.  Note that this could be made a bit brighter, by
+    # looking for JFIF and Adobe APP markers.
+
+    n = i16(self.fp.read(2)) - 2
+    s = ImageFile._safe_read(self.fp, n)
+    self._size = i16(s, 3), i16(s, 1)
+
+    self.bits = s[0]
+    if self.bits != 8:
+        msg = f"cannot handle {self.bits}-bit layers"
+        raise SyntaxError(msg)
+
+    self.layers = s[5]
+    if self.layers == 1:
+        self._mode = "L"
+    elif self.layers == 3:
+        self._mode = "RGB"
+    elif self.layers == 4:
+        self._mode = "CMYK"
+    else:
+        msg = f"cannot handle {self.layers}-layer images"
+        raise SyntaxError(msg)
+
+    if marker in [0xFFC2, 0xFFC6, 0xFFCA, 0xFFCE]:
+        self.info["progressive"] = self.info["progression"] = 1
+
+    if self.icclist:
+        # fixup icc profile
+        self.icclist.sort()  # sort by sequence number
+        if self.icclist[0][13] == len(self.icclist):
+            profile = []
+            for p in self.icclist:
+                profile.append(p[14:])
+            icc_profile = b"".join(profile)
+        else:
+            icc_profile = None  # wrong number of fragments
+        self.info["icc_profile"] = icc_profile
+        self.icclist = []
+
+    for i in range(6, len(s), 3):
+        t = s[i : i + 3]
+        # 4-tuples: id, vsamp, hsamp, qtable
+        self.layer.append((t[0], t[1] // 16, t[1] & 15, t[2]))
+
+
+def DQT(self, marker):
+    #
+    # Define quantization table.  Note that there might be more
+    # than one table in each marker.
+
+    # FIXME: The quantization tables can be used to estimate the
+    # compression quality.
+
+    n = i16(self.fp.read(2)) - 2
+    s = ImageFile._safe_read(self.fp, n)
+    while len(s):
+        v = s[0]
+        precision = 1 if (v // 16 == 0) else 2  # in bytes
+        qt_length = 1 + precision * 64
+        if len(s) < qt_length:
+            msg = "bad quantization table marker"
+            raise SyntaxError(msg)
+        data = array.array("B" if precision == 1 else "H", s[1:qt_length])
+        if sys.byteorder == "little" and precision > 1:
+            data.byteswap()  # the values are always big-endian
+        self.quantization[v & 15] = [data[i] for i in zigzag_index]
+        s = s[qt_length:]
+
+
+#
+# JPEG marker table
+
+MARKER = {
+    0xFFC0: ("SOF0", "Baseline DCT", SOF),
+    0xFFC1: ("SOF1", "Extended Sequential DCT", SOF),
+    0xFFC2: ("SOF2", "Progressive DCT", SOF),
+    0xFFC3: ("SOF3", "Spatial lossless", SOF),
+    0xFFC4: ("DHT", "Define Huffman table", Skip),
+    0xFFC5: ("SOF5", "Differential sequential DCT", SOF),
+    0xFFC6: ("SOF6", "Differential progressive DCT", SOF),
+    0xFFC7: ("SOF7", "Differential spatial", SOF),
+    0xFFC8: ("JPG", "Extension", None),
+    0xFFC9: ("SOF9", "Extended sequential DCT (AC)", SOF),
+    0xFFCA: ("SOF10", "Progressive DCT (AC)", SOF),
+    0xFFCB: ("SOF11", "Spatial lossless DCT (AC)", SOF),
+    0xFFCC: ("DAC", "Define arithmetic coding conditioning", Skip),
+    0xFFCD: ("SOF13", "Differential sequential DCT (AC)", SOF),
+    0xFFCE: ("SOF14", "Differential progressive DCT (AC)", SOF),
+    0xFFCF: ("SOF15", "Differential spatial (AC)", SOF),
+    0xFFD0: ("RST0", "Restart 0", None),
+    0xFFD1: ("RST1", "Restart 1", None),
+    0xFFD2: ("RST2", "Restart 2", None),
+    0xFFD3: ("RST3", "Restart 3", None),
+    0xFFD4: ("RST4", "Restart 4", None),
+    0xFFD5: ("RST5", "Restart 5", None),
+    0xFFD6: ("RST6", "Restart 6", None),
+    0xFFD7: ("RST7", "Restart 7", None),
+    0xFFD8: ("SOI", "Start of image", None),
+    0xFFD9: ("EOI", "End of image", None),
+    0xFFDA: ("SOS", "Start of scan", Skip),
+    0xFFDB: ("DQT", "Define quantization table", DQT),
+    0xFFDC: ("DNL", "Define number of lines", Skip),
+    0xFFDD: ("DRI", "Define restart interval", Skip),
+    0xFFDE: ("DHP", "Define hierarchical progression", SOF),
+    0xFFDF: ("EXP", "Expand reference component", Skip),
+    0xFFE0: ("APP0", "Application segment 0", APP),
+    0xFFE1: ("APP1", "Application segment 1", APP),
+    0xFFE2: ("APP2", "Application segment 2", APP),
+    0xFFE3: ("APP3", "Application segment 3", APP),
+    0xFFE4: ("APP4", "Application segment 4", APP),
+    0xFFE5: ("APP5", "Application segment 5", APP),
+    0xFFE6: ("APP6", "Application segment 6", APP),
+    0xFFE7: ("APP7", "Application segment 7", APP),
+    0xFFE8: ("APP8", "Application segment 8", APP),
+    0xFFE9: ("APP9", "Application segment 9", APP),
+    0xFFEA: ("APP10", "Application segment 10", APP),
+    0xFFEB: ("APP11", "Application segment 11", APP),
+    0xFFEC: ("APP12", "Application segment 12", APP),
+    0xFFED: ("APP13", "Application segment 13", APP),
+    0xFFEE: ("APP14", "Application segment 14", APP),
+    0xFFEF: ("APP15", "Application segment 15", APP),
+    0xFFF0: ("JPG0", "Extension 0", None),
+    0xFFF1: ("JPG1", "Extension 1", None),
+    0xFFF2: ("JPG2", "Extension 2", None),
+    0xFFF3: ("JPG3", "Extension 3", None),
+    0xFFF4: ("JPG4", "Extension 4", None),
+    0xFFF5: ("JPG5", "Extension 5", None),
+    0xFFF6: ("JPG6", "Extension 6", None),
+    0xFFF7: ("JPG7", "Extension 7", None),
+    0xFFF8: ("JPG8", "Extension 8", None),
+    0xFFF9: ("JPG9", "Extension 9", None),
+    0xFFFA: ("JPG10", "Extension 10", None),
+    0xFFFB: ("JPG11", "Extension 11", None),
+    0xFFFC: ("JPG12", "Extension 12", None),
+    0xFFFD: ("JPG13", "Extension 13", None),
+    0xFFFE: ("COM", "Comment", COM),
+}
+
+
+def _accept(prefix):
+    # Magic number was taken from https://en.wikipedia.org/wiki/JPEG
+    return prefix[:3] == b"\xFF\xD8\xFF"
+
+
+##
+# Image plugin for JPEG and JFIF images.
+
+
+class JpegImageFile(ImageFile.ImageFile):
+    format = "JPEG"
+    format_description = "JPEG (ISO 10918)"
+
+    def _open(self):
+        s = self.fp.read(3)
+
+        if not _accept(s):
+            msg = "not a JPEG file"
+            raise SyntaxError(msg)
+        s = b"\xFF"
+
+        # Create attributes
+        self.bits = self.layers = 0
+
+        # JPEG specifics (internal)
+        self.layer = []
+        self.huffman_dc = {}
+        self.huffman_ac = {}
+        self.quantization = {}
+        self.app = {}  # compatibility
+        self.applist = []
+        self.icclist = []
+
+        while True:
+            i = s[0]
+            if i == 0xFF:
+                s = s + self.fp.read(1)
+                i = i16(s)
+            else:
+                # Skip non-0xFF junk
+                s = self.fp.read(1)
+                continue
+
+            if i in MARKER:
+                name, description, handler = MARKER[i]
+                if handler is not None:
+                    handler(self, i)
+                if i == 0xFFDA:  # start of scan
+                    rawmode = self.mode
+                    if self.mode == "CMYK":
+                        rawmode = "CMYK;I"  # assume adobe conventions
+                    self.tile = [("jpeg", (0, 0) + self.size, 0, (rawmode, ""))]
+                    # self.__offset = self.fp.tell()
+                    break
+                s = self.fp.read(1)
+            elif i == 0 or i == 0xFFFF:
+                # padded marker or junk; move on
+                s = b"\xff"
+            elif i == 0xFF00:  # Skip extraneous data (escaped 0xFF)
+                s = self.fp.read(1)
+            else:
+                msg = "no marker found"
+                raise SyntaxError(msg)
+
+    def load_read(self, read_bytes):
+        """
+        internal: read more image data
+        For premature EOF and LOAD_TRUNCATED_IMAGES adds EOI marker
+        so libjpeg can finish decoding
+        """
+        s = self.fp.read(read_bytes)
+
+        if not s and ImageFile.LOAD_TRUNCATED_IMAGES and not hasattr(self, "_ended"):
+            # Premature EOF.
+            # Pretend file is finished adding EOI marker
+            self._ended = True
+            return b"\xFF\xD9"
+
+        return s
+
+    def draft(self, mode, size):
+        if len(self.tile) != 1:
+            return
+
+        # Protect from second call
+        if self.decoderconfig:
+            return
+
+        d, e, o, a = self.tile[0]
+        scale = 1
+        original_size = self.size
+
+        if a[0] == "RGB" and mode in ["L", "YCbCr"]:
+            self._mode = mode
+            a = mode, ""
+
+        if size:
+            scale = min(self.size[0] // size[0], self.size[1] // size[1])
+            for s in [8, 4, 2, 1]:
+                if scale >= s:
+                    break
+            e = (
+                e[0],
+                e[1],
+                (e[2] - e[0] + s - 1) // s + e[0],
+                (e[3] - e[1] + s - 1) // s + e[1],
+            )
+            self._size = ((self.size[0] + s - 1) // s, (self.size[1] + s - 1) // s)
+            scale = s
+
+        self.tile = [(d, e, o, a)]
+        self.decoderconfig = (scale, 0)
+
+        b

pairs/pair_29/output.txt

@@ -0,0 +1,2 @@
+ox = (0, 0, original_size[0] / scale, original_size[1] / scale)
+        return self.mode, box

pairs/pair_3/input.txt

@@ -0,0 +1,77 @@
+  for camera_model in CAMERA_MODELS])
+
+
+def qvec2rotmat(qvec):
+    return np.array([
+        [1 - 2 * qvec[2]**2 - 2 * qvec[3]**2,
+         2 * qvec[1] * qvec[2] - 2 * qvec[0] * qvec[3],
+         2 * qvec[3] * qvec[1] + 2 * qvec[0] * qvec[2]],
+        [2 * qvec[1] * qvec[2] + 2 * qvec[0] * qvec[3],
+         1 - 2 * qvec[1]**2 - 2 * qvec[3]**2,
+         2 * qvec[2] * qvec[3] - 2 * qvec[0] * qvec[1]],
+        [2 * qvec[3] * qvec[1] - 2 * qvec[0] * qvec[2],
+         2 * qvec[2] * qvec[3] + 2 * qvec[0] * qvec[1],
+         1 - 2 * qvec[1]**2 - 2 * qvec[2]**2]])
+
+def rotmat2qvec(R):
+    Rxx, Ryx, Rzx, Rxy, Ryy, Rzy, Rxz, Ryz, Rzz = R.flat
+    K = np.array([
+        [Rxx - Ryy - Rzz, 0, 0, 0],
+        [Ryx + Rxy, Ryy - Rxx - Rzz, 0, 0],
+        [Rzx + Rxz, Rzy + Ryz, Rzz - Rxx - Ryy, 0],
+        [Ryz - Rzy, Rzx - Rxz, Rxy - Ryx, Rxx + Ryy + Rzz]]) / 3.0
+    eigvals, eigvecs = np.linalg.eigh(K)
+    qvec = eigvecs[[3, 0, 1, 2], np.argmax(eigvals)]
+    if qvec[0] < 0:
+        qvec *= -1
+    return qvec
+
+class Image(BaseImage):
+    def qvec2rotmat(self):
+        return qvec2rotmat(self.qvec)
+
+def read_next_bytes(fid, num_bytes, format_char_sequence, endian_character="<"):
+    """Read and unpack the next bytes from a binary file.
+    :param fid:
+    :param num_bytes: Sum of combination of {2, 4, 8}, e.g. 2, 6, 16, 30, etc.
+    :param format_char_sequence: List of {c, e, f, d, h, H, i, I, l, L, q, Q}.
+    :param endian_character: Any of {@, =, <, >, !}
+    :return: Tuple of read and unpacked values.
+    """
+    data = fid.read(num_bytes)
+    return struct.unpack(endian_character + format_char_sequence, data)
+
+def read_points3D_text(path):
+    """
+    see: src/base/reconstruction.cc
+        void Reconstruction::ReadPoints3DText(const std::string& path)
+        void Reconstruction::WritePoints3DText(const std::string& path)
+    """
+    xyzs = None
+    rgbs = None
+    errors = None
+    num_points = 0
+    with open(path, "r") as fid:
+        while True:
+            line = fid.readline()
+            if not line:
+                break
+            line = line.strip()
+            if len(line) > 0 and line[0] != "#":
+                num_points += 1
+
+
+    xyzs = np.empty((num_points, 3))
+    rgbs = np.empty((num_points, 3))
+    errors = np.empty((num_points, 1))
+    count = 0
+    with open(path, "r") as fid:
+        while True:
+            line = fid.readline()
+            if not line:
+                break
+            line = line.strip()
+            if len(line) > 0 and line[0] != "#":
+                elems = line.split()
+                xyz = np.array(tuple(map(float, elems[1:4])))
+    

pairs/pair_3/output.txt

@@ -0,0 +1,8 @@
+            rgb = np.array(tuple(map(int, elems[4:7])))
+                error = np.array(float(elems[7]))
+                xyzs[count] = xyz
+                rgbs[count] = rgb
+                errors[count] = error
+                count += 1
+
+    return xyzs, rgbs, errors

pairs/pair_30/input.txt

@@ -0,0 +1,62 @@
+import contextlib
+import os.path
+
+import pytest
+
+from PIL import Image, ImageColor, ImageDraw, ImageFont, features
+
+from .helper import (
+    assert_image_equal,
+    assert_image_equal_tofile,
+    assert_image_similar_tofile,
+    hopper,
+    skip_unless_feature,
+)
+
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+GRAY = (190, 190, 190)
+DEFAULT_MODE = "RGB"
+IMAGES_PATH = os.path.join("Tests", "images", "imagedraw")
+
+# Image size
+W, H = 100, 100
+
+# Bounding box points
+X0 = int(W / 4)
+X1 = int(X0 * 3)
+Y0 = int(H / 4)
+Y1 = int(X0 * 3)
+
+# Bounding boxes
+BBOX = (((X0, Y0), (X1, Y1)), [(X0, Y0), (X1, Y1)], (X0, Y0, X1, Y1), [X0, Y0, X1, Y1])
+
+# Coordinate sequences
+POINTS = (
+    ((10, 10), (20, 40), (30, 30)),
+    [(10, 10), (20, 40), (30, 30)],
+    (10, 10, 20, 40, 30, 30),
+    [10, 10, 20, 40, 30, 30],
+)
+
+KITE_POINTS = (
+    ((10, 50), (70, 10), (90, 50), (70, 90), (10, 50)),
+    [(10, 50), (70, 10), (90, 50), (70, 90), (10, 50)],
+)
+
+
+def test_sanity():
+    im = hopper("RGB").copy()
+
+    draw = ImageDraw.ImageDraw(im)
+    draw = ImageDraw.Draw(im)
+
+    draw.ellipse(list(range(4)))
+    draw.line(list(range(10)))
+    draw.polygon(list(range(100)))
+    draw.rectangle(list(range(4)))
+
+
+def test_valueerror():
+    with Image.open("Tests/images/chi.gif") as im:
+        draw

pairs/pair_30/output.txt

@@ -0,0 +1,2 @@
+ = ImageDraw.Draw(im)
+        draw.line((0, 0), fill=(0, 0, 0))