We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Default guide for `Importance` gives non-zero `log_weight`
The default `guide` in `Importance` blocks _all_ sites (and not just those observed). This leads to the `guide_trace` being empty (except for the input and return values). As a result, no samples are reused when replayed on the model _and_ the `guide_trace.log_pdf()` evaluates to `0.0`. The `log_weight` is then equal to the `model_trace.log_pdf()` (which is also evaluated on different samples), which I believe is unintended and incorrect.

The program below illustrates this for a simple univariate Gaussian, where my proposal and target distribution are identical and I would expect the log of the weights to be `0.0`. The latter is only the case when the sites are _explicitly_ exposed.

```python
import torch
from torch.autograd import Variable

import pyro
from pyro import distributions as dist
from pyro import infer
from pyro import poutine


def gaussian():
    return pyro.sample('x', dist.normal,
                       Variable(torch.Tensor([0.0])),
                       Variable(torch.Tensor([1.0])))


# Using `Importance` with the default `guide`, the `log_weight` is equal to the
# `model_trace.log_pdf()`. That is, the `guide_trace.log_pdf()` (evaluated
# internally) is incorrectly `0.0`.
print('importance_default_guide:')
importance_default_guide = infer.Importance(gaussian, num_samples=10)
for model_trace, log_weight in importance_default_guide._traces():
    model_trace_log_pdf = model_trace.log_pdf()
    are_equal = log_weight.data[0] == model_trace_log_pdf.data[0]
    print(log_weight.data[0], are_equal)

# However, setting the `guide` to expose `x` ensures that it is replayed so
# that the `log_weight` is exactly zero for each sample.
print('importance_exposed_guide:')
importance_exposed_guide = infer.Importance(
    gaussian,
    guide=poutine.block(gaussian, expose=['x']),
    num_samples=10)
for model_trace, log_weight in importance_exposed_guide._traces():
    print(log_weight.data[0])
```
```
importance_default_guide:
-0.9368391633033752 True
-1.3421428203582764 True
-0.9189755320549011 True
-2.1423826217651367 True
-2.301940679550171 True
-1.142196774482727 True
-0.9449963569641113 True
-2.7146053314208984 True
-3.420013904571533 True
-1.7994171380996704 True
importance_exposed_guide:
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
```

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `pyro/poutine/block_poutine.py`
Content:
```
1 from __future__ import absolute_import, division, print_function
2 
3 from .poutine import Poutine
4 
5 
6 class BlockPoutine(Poutine):
7     """
8     This Poutine selectively hides pyro primitive sites from the outside world.
9 
10     For example, suppose the stochastic function fn has two sample sites "a" and "b".
11     Then any poutine outside of BlockPoutine(fn, hide=["a"])
12     will not be applied to site "a" and will only see site "b":
13 
14     >>> fn_inner = TracePoutine(fn)
15     >>> fn_outer = TracePoutine(BlockPoutine(TracePoutine(fn), hide=["a"]))
16     >>> trace_inner = fn_inner.get_trace()
17     >>> trace_outer  = fn_outer.get_trace()
18     >>> "a" in trace_inner
19     True
20     >>> "a" in trace_outer
21     False
22     >>> "b" in trace_inner
23     True
24     >>> "b" in trace_outer
25     True
26 
27     BlockPoutine has a flexible interface that allows users
28     to specify in several different ways
29     which sites should be hidden or exposed.
30     See the constructor for details.
31     """
32 
33     def __init__(self, fn,
34                  hide_all=True, expose_all=False,
35                  hide=None, expose=None,
36                  hide_types=None, expose_types=None):
37         """
38         :param bool hide_all: hide all sites
39         :param bool expose_all: expose all sites normally
40         :param list hide: list of site names to hide, rest will be exposed normally
41         :param list expose: list of site names to expose, rest will be hidden
42         :param list hide_types: list of site types to hide, rest will be exposed normally
43         :param list expose_types: list of site types to expose normally, rest will be hidden
44 
45         Constructor for blocking poutine
46         Default behavior: block everything (hide_all == True)
47 
48         A site is hidden if at least one of the following holds:
49         1. msg["name"] in hide
50         2. msg["type"] in hide_types
51         3. msg["name"] not in expose and msg["type"] not in expose_types
52         4. hide_all == True
53         """
54         super(BlockPoutine, self).__init__(fn)
55         # first, some sanity checks:
56         # hide_all and expose_all intersect?
57         assert (hide_all is False and expose_all is False) or \
58                (hide_all != expose_all), "cannot hide and expose a site"
59 
60         # hide and expose intersect?
61         if hide is None:
62             hide = []
63         else:
64             hide_all = False
65 
66         if expose is None:
67             expose = []
68         assert set(hide).isdisjoint(set(expose)), \
69             "cannot hide and expose a site"
70 
71         # hide_types and expose_types intersect?
72         if hide_types is None:
73             hide_types = []
74         if expose_types is None:
75             expose_types = []
76         assert set(hide_types).isdisjoint(set(expose_types)), \
77             "cannot hide and expose a site type"
78 
79         # now set stuff
80         self.hide_all = hide_all
81         self.expose_all = expose_all
82         self.hide = hide
83         self.expose = expose
84         self.hide_types = hide_types
85         self.expose_types = expose_types
86 
87     def _block_up(self, msg):
88         """
89         :param msg: current message at a trace site, after all execution finished.
90         :returns: boolean decision to hide or expose site.
91 
92         A site is hidden if at least one of the following holds:
93         1. msg["name"] in self.hide
94         2. msg["type"] in self.hide_types
95         3. msg["name"] not in self.expose and msg["type"] not in self.expose_types
96         4. self.hide_all == True
97         """
98         # handle observes
99         if msg["type"] == "sample" and msg["is_observed"]:
100             msg_type = "observe"
101         else:
102             msg_type = msg["type"]
103 
104         # decision rule for hiding:
105         if (msg["name"] in self.hide) or \
106            (msg_type in self.hide_types) or \
107            ((msg["name"] not in self.expose) and
108             (msg_type not in self.expose_types) and self.hide_all):  # noqa: E129
109 
110             return True
111         # otherwise expose
112         else:
113             return False
114 
115     def _pyro_sample(self, msg):
116         """
117         :param msg:  current message at a trace site
118         :returns: a sample from the stochastic function at the site.
119 
120         Default sample behavior with a side effect.
121         Applies self._block_up to decide whether to hide the site.
122         """
123         ret = super(BlockPoutine, self)._pyro_sample(msg)
124         msg["stop"] = self._block_up(msg)
125         return ret
126 
127     def _pyro_param(self, msg):
128         """
129         :param msg:  current message at a trace site
130         :returns: the result of querying the parameter store.
131 
132         Default param behavior with a side effect.
133         Applies self._block_up to decide whether to hide the site.
134         """
135         ret = super(BlockPoutine, self)._pyro_param(msg)
136         msg["stop"] = self._block_up(msg)
137         return ret
138
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/pyro/poutine/block_poutine.py b/pyro/poutine/block_poutine.py
--- a/pyro/poutine/block_poutine.py
+++ b/pyro/poutine/block_poutine.py
@@ -49,7 +49,7 @@
         1. msg["name"] in hide
         2. msg["type"] in hide_types
         3. msg["name"] not in expose and msg["type"] not in expose_types
-        4. hide_all == True
+        4. hide_all == True and hide, hide_types, and expose_types are all None
         """
         super(BlockPoutine, self).__init__(fn)
         # first, some sanity checks:
@@ -65,14 +65,23 @@
 
         if expose is None:
             expose = []
+        else:
+            hide_all = True
+
         assert set(hide).isdisjoint(set(expose)), \
             "cannot hide and expose a site"
 
         # hide_types and expose_types intersect?
         if hide_types is None:
             hide_types = []
+        else:
+            hide_all = False
+
         if expose_types is None:
             expose_types = []
+        else:
+            hide_all = True
+
         assert set(hide_types).isdisjoint(set(expose_types)), \
             "cannot hide and expose a site type"
 
@@ -93,7 +102,7 @@
         1. msg["name"] in self.hide
         2. msg["type"] in self.hide_types
         3. msg["name"] not in self.expose and msg["type"] not in self.expose_types
-        4. self.hide_all == True
+        4. self.hide_all == True and hide, hide_types, and expose_types are all None
         """
         # handle observes
         if msg["type"] == "sample" and msg["is_observed"]:
@@ -101,11 +110,13 @@
         else:
             msg_type = msg["type"]
 
+        is_not_exposed = (msg["name"] not in self.expose) and \
+                         (msg_type not in self.expose_types)
+
         # decision rule for hiding:
         if (msg["name"] in self.hide) or \
            (msg_type in self.hide_types) or \
-           ((msg["name"] not in self.expose) and
-            (msg_type not in self.expose_types) and self.hide_all):  # noqa: E129
+           (is_not_exposed and self.hide_all):  # noqa: E129
 
             return True
         # otherwise expose

{"golden_diff": "diff --git a/pyro/poutine/block_poutine.py b/pyro/poutine/block_poutine.py\n--- a/pyro/poutine/block_poutine.py\n+++ b/pyro/poutine/block_poutine.py\n@@ -49,7 +49,7 @@\n         1. msg[\"name\"] in hide\n         2. msg[\"type\"] in hide_types\n         3. msg[\"name\"] not in expose and msg[\"type\"] not in expose_types\n-        4. hide_all == True\n+        4. hide_all == True and hide, hide_types, and expose_types are all None\n         \"\"\"\n         super(BlockPoutine, self).__init__(fn)\n         # first, some sanity checks:\n@@ -65,14 +65,23 @@\n \n         if expose is None:\n             expose = []\n+        else:\n+            hide_all = True\n+\n         assert set(hide).isdisjoint(set(expose)), \\\n             \"cannot hide and expose a site\"\n \n         # hide_types and expose_types intersect?\n         if hide_types is None:\n             hide_types = []\n+        else:\n+            hide_all = False\n+\n         if expose_types is None:\n             expose_types = []\n+        else:\n+            hide_all = True\n+\n         assert set(hide_types).isdisjoint(set(expose_types)), \\\n             \"cannot hide and expose a site type\"\n \n@@ -93,7 +102,7 @@\n         1. msg[\"name\"] in self.hide\n         2. msg[\"type\"] in self.hide_types\n         3. msg[\"name\"] not in self.expose and msg[\"type\"] not in self.expose_types\n-        4. self.hide_all == True\n+        4. self.hide_all == True and hide, hide_types, and expose_types are all None\n         \"\"\"\n         # handle observes\n         if msg[\"type\"] == \"sample\" and msg[\"is_observed\"]:\n@@ -101,11 +110,13 @@\n         else:\n             msg_type = msg[\"type\"]\n \n+        is_not_exposed = (msg[\"name\"] not in self.expose) and \\\n+                         (msg_type not in self.expose_types)\n+\n         # decision rule for hiding:\n         if (msg[\"name\"] in self.hide) or \\\n            (msg_type in self.hide_types) or \\\n-           ((msg[\"name\"] not in self.expose) and\n-            (msg_type not in self.expose_types) and self.hide_all):  # noqa: E129\n+           (is_not_exposed and self.hide_all):  # noqa: E129\n \n             return True\n         # otherwise expose\n", "issue": "Default guide for `Importance` gives non-zero `log_weight`\nThe default `guide` in `Importance` blocks _all_ sites (and not just those observed). This leads to the `guide_trace` being empty (except for the input and return values). As a result, no samples are reused when replayed on the model _and_ the `guide_trace.log_pdf()` evaluates to `0.0`. The `log_weight` is then equal to the `model_trace.log_pdf()` (which is also evaluated on different samples), which I believe is unintended and incorrect.\r\n\r\nThe program below illustrates this for a simple univariate Gaussian, where my proposal and target distribution are identical and I would expect the log of the weights to be `0.0`. The latter is only the case when the sites are _explicitly_ exposed.\r\n\r\n```python\r\nimport torch\r\nfrom torch.autograd import Variable\r\n\r\nimport pyro\r\nfrom pyro import distributions as dist\r\nfrom pyro import infer\r\nfrom pyro import poutine\r\n\r\n\r\ndef gaussian():\r\n    return pyro.sample('x', dist.normal,\r\n                       Variable(torch.Tensor([0.0])),\r\n                       Variable(torch.Tensor([1.0])))\r\n\r\n\r\n# Using `Importance` with the default `guide`, the `log_weight` is equal to the\r\n# `model_trace.log_pdf()`. That is, the `guide_trace.log_pdf()` (evaluated\r\n# internally) is incorrectly `0.0`.\r\nprint('importance_default_guide:')\r\nimportance_default_guide = infer.Importance(gaussian, num_samples=10)\r\nfor model_trace, log_weight in importance_default_guide._traces():\r\n    model_trace_log_pdf = model_trace.log_pdf()\r\n    are_equal = log_weight.data[0] == model_trace_log_pdf.data[0]\r\n    print(log_weight.data[0], are_equal)\r\n\r\n# However, setting the `guide` to expose `x` ensures that it is replayed so\r\n# that the `log_weight` is exactly zero for each sample.\r\nprint('importance_exposed_guide:')\r\nimportance_exposed_guide = infer.Importance(\r\n    gaussian,\r\n    guide=poutine.block(gaussian, expose=['x']),\r\n    num_samples=10)\r\nfor model_trace, log_weight in importance_exposed_guide._traces():\r\n    print(log_weight.data[0])\r\n```\r\n```\r\nimportance_default_guide:\r\n-0.9368391633033752 True\r\n-1.3421428203582764 True\r\n-0.9189755320549011 True\r\n-2.1423826217651367 True\r\n-2.301940679550171 True\r\n-1.142196774482727 True\r\n-0.9449963569641113 True\r\n-2.7146053314208984 True\r\n-3.420013904571533 True\r\n-1.7994171380996704 True\r\nimportance_exposed_guide:\r\n0.0\r\n0.0\r\n0.0\r\n0.0\r\n0.0\r\n0.0\r\n0.0\r\n0.0\r\n0.0\r\n0.0\r\n```\n", "before_files": [{"content": "from __future__ import absolute_import, division, print_function\n\nfrom .poutine import Poutine\n\n\nclass BlockPoutine(Poutine):\n    \"\"\"\n    This Poutine selectively hides pyro primitive sites from the outside world.\n\n    For example, suppose the stochastic function fn has two sample sites \"a\" and \"b\".\n    Then any poutine outside of BlockPoutine(fn, hide=[\"a\"])\n    will not be applied to site \"a\" and will only see site \"b\":\n\n    >>> fn_inner = TracePoutine(fn)\n    >>> fn_outer = TracePoutine(BlockPoutine(TracePoutine(fn), hide=[\"a\"]))\n    >>> trace_inner = fn_inner.get_trace()\n    >>> trace_outer  = fn_outer.get_trace()\n    >>> \"a\" in trace_inner\n    True\n    >>> \"a\" in trace_outer\n    False\n    >>> \"b\" in trace_inner\n    True\n    >>> \"b\" in trace_outer\n    True\n\n    BlockPoutine has a flexible interface that allows users\n    to specify in several different ways\n    which sites should be hidden or exposed.\n    See the constructor for details.\n    \"\"\"\n\n    def __init__(self, fn,\n                 hide_all=True, expose_all=False,\n                 hide=None, expose=None,\n                 hide_types=None, expose_types=None):\n        \"\"\"\n        :param bool hide_all: hide all sites\n        :param bool expose_all: expose all sites normally\n        :param list hide: list of site names to hide, rest will be exposed normally\n        :param list expose: list of site names to expose, rest will be hidden\n        :param list hide_types: list of site types to hide, rest will be exposed normally\n        :param list expose_types: list of site types to expose normally, rest will be hidden\n\n        Constructor for blocking poutine\n        Default behavior: block everything (hide_all == True)\n\n        A site is hidden if at least one of the following holds:\n        1. msg[\"name\"] in hide\n        2. msg[\"type\"] in hide_types\n        3. msg[\"name\"] not in expose and msg[\"type\"] not in expose_types\n        4. hide_all == True\n        \"\"\"\n        super(BlockPoutine, self).__init__(fn)\n        # first, some sanity checks:\n        # hide_all and expose_all intersect?\n        assert (hide_all is False and expose_all is False) or \\\n               (hide_all != expose_all), \"cannot hide and expose a site\"\n\n        # hide and expose intersect?\n        if hide is None:\n            hide = []\n        else:\n            hide_all = False\n\n        if expose is None:\n            expose = []\n        assert set(hide).isdisjoint(set(expose)), \\\n            \"cannot hide and expose a site\"\n\n        # hide_types and expose_types intersect?\n        if hide_types is None:\n            hide_types = []\n        if expose_types is None:\n            expose_types = []\n        assert set(hide_types).isdisjoint(set(expose_types)), \\\n            \"cannot hide and expose a site type\"\n\n        # now set stuff\n        self.hide_all = hide_all\n        self.expose_all = expose_all\n        self.hide = hide\n        self.expose = expose\n        self.hide_types = hide_types\n        self.expose_types = expose_types\n\n    def _block_up(self, msg):\n        \"\"\"\n        :param msg: current message at a trace site, after all execution finished.\n        :returns: boolean decision to hide or expose site.\n\n        A site is hidden if at least one of the following holds:\n        1. msg[\"name\"] in self.hide\n        2. msg[\"type\"] in self.hide_types\n        3. msg[\"name\"] not in self.expose and msg[\"type\"] not in self.expose_types\n        4. self.hide_all == True\n        \"\"\"\n        # handle observes\n        if msg[\"type\"] == \"sample\" and msg[\"is_observed\"]:\n            msg_type = \"observe\"\n        else:\n            msg_type = msg[\"type\"]\n\n        # decision rule for hiding:\n        if (msg[\"name\"] in self.hide) or \\\n           (msg_type in self.hide_types) or \\\n           ((msg[\"name\"] not in self.expose) and\n            (msg_type not in self.expose_types) and self.hide_all):  # noqa: E129\n\n            return True\n        # otherwise expose\n        else:\n            return False\n\n    def _pyro_sample(self, msg):\n        \"\"\"\n        :param msg:  current message at a trace site\n        :returns: a sample from the stochastic function at the site.\n\n        Default sample behavior with a side effect.\n        Applies self._block_up to decide whether to hide the site.\n        \"\"\"\n        ret = super(BlockPoutine, self)._pyro_sample(msg)\n        msg[\"stop\"] = self._block_up(msg)\n        return ret\n\n    def _pyro_param(self, msg):\n        \"\"\"\n        :param msg:  current message at a trace site\n        :returns: the result of querying the parameter store.\n\n        Default param behavior with a side effect.\n        Applies self._block_up to decide whether to hide the site.\n        \"\"\"\n        ret = super(BlockPoutine, self)._pyro_param(msg)\n        msg[\"stop\"] = self._block_up(msg)\n        return ret\n", "path": "pyro/poutine/block_poutine.py"}], "after_files": [{"content": "from __future__ import absolute_import, division, print_function\n\nfrom .poutine import Poutine\n\n\nclass BlockPoutine(Poutine):\n    \"\"\"\n    This Poutine selectively hides pyro primitive sites from the outside world.\n\n    For example, suppose the stochastic function fn has two sample sites \"a\" and \"b\".\n    Then any poutine outside of BlockPoutine(fn, hide=[\"a\"])\n    will not be applied to site \"a\" and will only see site \"b\":\n\n    >>> fn_inner = TracePoutine(fn)\n    >>> fn_outer = TracePoutine(BlockPoutine(TracePoutine(fn), hide=[\"a\"]))\n    >>> trace_inner = fn_inner.get_trace()\n    >>> trace_outer  = fn_outer.get_trace()\n    >>> \"a\" in trace_inner\n    True\n    >>> \"a\" in trace_outer\n    False\n    >>> \"b\" in trace_inner\n    True\n    >>> \"b\" in trace_outer\n    True\n\n    BlockPoutine has a flexible interface that allows users\n    to specify in several different ways\n    which sites should be hidden or exposed.\n    See the constructor for details.\n    \"\"\"\n\n    def __init__(self, fn,\n                 hide_all=True, expose_all=False,\n                 hide=None, expose=None,\n                 hide_types=None, expose_types=None):\n        \"\"\"\n        :param bool hide_all: hide all sites\n        :param bool expose_all: expose all sites normally\n        :param list hide: list of site names to hide, rest will be exposed normally\n        :param list expose: list of site names to expose, rest will be hidden\n        :param list hide_types: list of site types to hide, rest will be exposed normally\n        :param list expose_types: list of site types to expose normally, rest will be hidden\n\n        Constructor for blocking poutine\n        Default behavior: block everything (hide_all == True)\n\n        A site is hidden if at least one of the following holds:\n        1. msg[\"name\"] in hide\n        2. msg[\"type\"] in hide_types\n        3. msg[\"name\"] not in expose and msg[\"type\"] not in expose_types\n        4. hide_all == True and hide, hide_types, and expose_types are all None\n        \"\"\"\n        super(BlockPoutine, self).__init__(fn)\n        # first, some sanity checks:\n        # hide_all and expose_all intersect?\n        assert (hide_all is False and expose_all is False) or \\\n               (hide_all != expose_all), \"cannot hide and expose a site\"\n\n        # hide and expose intersect?\n        if hide is None:\n            hide = []\n        else:\n            hide_all = False\n\n        if expose is None:\n            expose = []\n        else:\n            hide_all = True\n\n        assert set(hide).isdisjoint(set(expose)), \\\n            \"cannot hide and expose a site\"\n\n        # hide_types and expose_types intersect?\n        if hide_types is None:\n            hide_types = []\n        else:\n            hide_all = False\n\n        if expose_types is None:\n            expose_types = []\n        else:\n            hide_all = True\n\n        assert set(hide_types).isdisjoint(set(expose_types)), \\\n            \"cannot hide and expose a site type\"\n\n        # now set stuff\n        self.hide_all = hide_all\n        self.expose_all = expose_all\n        self.hide = hide\n        self.expose = expose\n        self.hide_types = hide_types\n        self.expose_types = expose_types\n\n    def _block_up(self, msg):\n        \"\"\"\n        :param msg: current message at a trace site, after all execution finished.\n        :returns: boolean decision to hide or expose site.\n\n        A site is hidden if at least one of the following holds:\n        1. msg[\"name\"] in self.hide\n        2. msg[\"type\"] in self.hide_types\n        3. msg[\"name\"] not in self.expose and msg[\"type\"] not in self.expose_types\n        4. self.hide_all == True and hide, hide_types, and expose_types are all None\n        \"\"\"\n        # handle observes\n        if msg[\"type\"] == \"sample\" and msg[\"is_observed\"]:\n            msg_type = \"observe\"\n        else:\n            msg_type = msg[\"type\"]\n\n        is_not_exposed = (msg[\"name\"] not in self.expose) and \\\n                         (msg_type not in self.expose_types)\n\n        # decision rule for hiding:\n        if (msg[\"name\"] in self.hide) or \\\n           (msg_type in self.hide_types) or \\\n           (is_not_exposed and self.hide_all):  # noqa: E129\n\n            return True\n        # otherwise expose\n        else:\n            return False\n\n    def _pyro_sample(self, msg):\n        \"\"\"\n        :param msg:  current message at a trace site\n        :returns: a sample from the stochastic function at the site.\n\n        Default sample behavior with a side effect.\n        Applies self._block_up to decide whether to hide the site.\n        \"\"\"\n        ret = super(BlockPoutine, self)._pyro_sample(msg)\n        msg[\"stop\"] = self._block_up(msg)\n        return ret\n\n    def _pyro_param(self, msg):\n        \"\"\"\n        :param msg:  current message at a trace site\n        :returns: the result of querying the parameter store.\n\n        Default param behavior with a side effect.\n        Applies self._block_up to decide whether to hide the site.\n        \"\"\"\n        ret = super(BlockPoutine, self)._pyro_param(msg)\n        msg[\"stop\"] = self._block_up(msg)\n        return ret\n", "path": "pyro/poutine/block_poutine.py"}]}