tensorbored 2.21.0rc1769983804__py3-none-any.whl

tensorbored/backend/event_processing/reservoir.py

@@ -0,0 +1,266 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""A key-value[] store that implements reservoir sampling on the values."""
+
+import collections
+import random
+import threading
+
+
+class Reservoir:
+    """A map-to-arrays container, with deterministic Reservoir Sampling.
+
+    Items are added with an associated key. Items may be retrieved by key, and
+    a list of keys can also be retrieved. If size is not zero, then it dictates
+    the maximum number of items that will be stored with each key. Once there are
+    more items for a given key, they are replaced via reservoir sampling, such
+    that each item has an equal probability of being included in the sample.
+
+    Deterministic means that for any given seed and bucket size, the sequence of
+    values that are kept for any given tag will always be the same, and that this
+    is independent of any insertions on other tags. That is:
+
+    >>> separate_reservoir = reservoir.Reservoir(10)
+    >>> interleaved_reservoir = reservoir.Reservoir(10)
+    >>> for i in range(100):
+    >>>   separate_reservoir.AddItem('key1', i)
+    >>> for i in range(100):
+    >>>   separate_reservoir.AddItem('key2', i)
+    >>> for i in range(100):
+    >>>   interleaved_reservoir.AddItem('key1', i)
+    >>>   interleaved_reservoir.AddItem('key2', i)
+
+    separate_reservoir and interleaved_reservoir will be in identical states.
+
+    See: https://en.wikipedia.org/wiki/Reservoir_sampling
+
+    Adding items has amortized O(1) runtime.
+
+    Fields:
+      always_keep_last: Whether the latest seen sample is always at the
+        end of the reservoir. Defaults to True.
+      size: An integer of the maximum number of samples.
+    """
+
+    def __init__(self, size, seed=0, always_keep_last=True):
+        """Creates a new reservoir.
+
+        Args:
+          size: The number of values to keep in the reservoir for each tag. If 0,
+            all values will be kept.
+          seed: The seed of the random number generator to use when sampling.
+            Different values for |seed| will produce different samples from the same
+            input items.
+          always_keep_last: Whether to always keep the latest seen item in the
+            end of the reservoir. Defaults to True.
+
+        Raises:
+          ValueError: If size is negative or not an integer.
+        """
+        if size < 0 or size != round(size):
+            raise ValueError("size must be nonnegative integer, was %s" % size)
+        self._buckets = collections.defaultdict(
+            lambda: _ReservoirBucket(
+                size, random.Random(seed), always_keep_last
+            )
+        )
+        # _mutex guards the keys - creating new keys, retrieving by key, etc
+        # the internal items are guarded by the ReservoirBuckets' internal mutexes
+        self._mutex = threading.Lock()
+        self.size = size
+        self.always_keep_last = always_keep_last
+
+    def Keys(self):
+        """Return all the keys in the reservoir.
+
+        Returns:
+          ['list', 'of', 'keys'] in the Reservoir.
+        """
+        with self._mutex:
+            return list(self._buckets.keys())
+
+    def Items(self, key):
+        """Return items associated with given key.
+
+        Args:
+          key: The key for which we are finding associated items.
+
+        Raises:
+          KeyError: If the key is not found in the reservoir.
+
+        Returns:
+          [list, of, items] associated with that key.
+        """
+        with self._mutex:
+            if key not in self._buckets:
+                raise KeyError("Key %s was not found in Reservoir" % key)
+            bucket = self._buckets[key]
+        return bucket.Items()
+
+    def AddItem(self, key, item, f=lambda x: x):
+        """Add a new item to the Reservoir with the given tag.
+
+        If the reservoir has not yet reached full size, the new item is guaranteed
+        to be added. If the reservoir is full, then behavior depends on the
+        always_keep_last boolean.
+
+        If always_keep_last was set to true, the new item is guaranteed to be added
+        to the reservoir, and either the previous last item will be replaced, or
+        (with low probability) an older item will be replaced.
+
+        If always_keep_last was set to false, then the new item will replace an
+        old item with low probability.
+
+        If f is provided, it will be applied to transform item (lazily, iff item is
+          going to be included in the reservoir).
+
+        Args:
+          key: The key to store the item under.
+          item: The item to add to the reservoir.
+          f: An optional function to transform the item prior to addition.
+        """
+        with self._mutex:
+            bucket = self._buckets[key]
+        bucket.AddItem(item, f)
+
+    def FilterItems(self, filterFn, key=None):
+        """Filter items within a Reservoir, using a filtering function.
+
+        Args:
+          filterFn: A function that returns True for the items to be kept.
+          key: An optional bucket key to filter. If not specified, will filter all
+            all buckets.
+
+        Returns:
+          The number of items removed.
+        """
+        with self._mutex:
+            if key:
+                if key in self._buckets:
+                    return self._buckets[key].FilterItems(filterFn)
+                else:
+                    return 0
+            else:
+                return sum(
+                    bucket.FilterItems(filterFn)
+                    for bucket in self._buckets.values()
+                )
+
+
+class _ReservoirBucket:
+    """A container for items from a stream, that implements reservoir sampling.
+
+    It always stores the most recent item as its final item.
+    """
+
+    def __init__(self, _max_size, _random=None, always_keep_last=True):
+        """Create the _ReservoirBucket.
+
+        Args:
+          _max_size: The maximum size the reservoir bucket may grow to. If size is
+            zero, the bucket has unbounded size.
+          _random: The random number generator to use. If not specified, defaults to
+            random.Random(0).
+          always_keep_last: Whether the latest seen item should always be included
+            in the end of the bucket.
+
+        Raises:
+          ValueError: if the size is not a nonnegative integer.
+        """
+        if _max_size < 0 or _max_size != round(_max_size):
+            raise ValueError(
+                "_max_size must be nonnegative int, was %s" % _max_size
+            )
+        self.items = []
+        # This mutex protects the internal items, ensuring that calls to Items and
+        # AddItem are thread-safe
+        self._mutex = threading.Lock()
+        self._max_size = _max_size
+        self._num_items_seen = 0
+        if _random is not None:
+            self._random = _random
+        else:
+            self._random = random.Random(0)
+        self.always_keep_last = always_keep_last
+
+    def AddItem(self, item, f=lambda x: x):
+        """Add an item to the ReservoirBucket, replacing an old item if
+        necessary.
+
+        The new item is guaranteed to be added to the bucket, and to be the last
+        element in the bucket. If the bucket has reached capacity, then an old item
+        will be replaced. With probability (_max_size/_num_items_seen) a random item
+        in the bucket will be popped out and the new item will be appended
+        to the end. With probability (1 - _max_size/_num_items_seen)
+        the last item in the bucket will be replaced.
+
+        Since the O(n) replacements occur with O(1/_num_items_seen) likelihood,
+        the amortized runtime is O(1).
+
+        Args:
+          item: The item to add to the bucket.
+          f: A function to transform item before addition, if it will be kept in
+            the reservoir.
+        """
+        with self._mutex:
+            if len(self.items) < self._max_size or self._max_size == 0:
+                self.items.append(f(item))
+            else:
+                r = self._random.randint(0, self._num_items_seen)
+                if r < self._max_size:
+                    self.items.pop(r)
+                    self.items.append(f(item))
+                elif self.always_keep_last:
+                    self.items[-1] = f(item)
+            self._num_items_seen += 1
+
+    def FilterItems(self, filterFn):
+        """Filter items in a ReservoirBucket, using a filtering function.
+
+        Filtering items from the reservoir bucket must update the
+        internal state variable self._num_items_seen, which is used for determining
+        the rate of replacement in reservoir sampling. Ideally, self._num_items_seen
+        would contain the exact number of items that have ever seen by the
+        ReservoirBucket and satisfy filterFn. However, the ReservoirBucket does not
+        have access to all items seen -- it only has access to the subset of items
+        that have survived sampling (self.items). Therefore, we estimate
+        self._num_items_seen by scaling it by the same ratio as the ratio of items
+        not removed from self.items.
+
+        Args:
+          filterFn: A function that returns True for items to be kept.
+
+        Returns:
+          The number of items removed from the bucket.
+        """
+        with self._mutex:
+            size_before = len(self.items)
+            self.items = list(filter(filterFn, self.items))
+            size_diff = size_before - len(self.items)
+
+            # Estimate a correction the number of items seen
+            prop_remaining = (
+                len(self.items) / float(size_before) if size_before > 0 else 0
+            )
+            self._num_items_seen = int(
+                round(self._num_items_seen * prop_remaining)
+            )
+            return size_diff
+
+    def Items(self):
+        """Get all the items in the bucket."""
+        with self._mutex:
+            return list(self.items)

tensorbored/backend/event_processing/tag_types.py

@@ -0,0 +1,29 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""String constants describing contents of an event accumulator."""
+
+# Arbitrary strings chosen to pass the type information of the tag from
+# the backend to the frontend.
+TENSORS = "tensors"
+GRAPH = "graph"
+META_GRAPH = "meta_graph"
+RUN_METADATA = "run_metadata"
+
+# Legacy (pre-tensor) tag types.
+COMPRESSED_HISTOGRAMS = "distributions"
+HISTOGRAMS = "histograms"
+IMAGES = "images"
+AUDIO = "audio"
+SCALARS = "scalars"

tensorbored/backend/experiment_id.py

@@ -0,0 +1,71 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Application-level experiment ID support."""
+
+import re
+
+# Value of the first path component that signals that the second path
+# component represents an experiment ID.
+_EXPERIMENT_PATH_COMPONENT = "experiment"
+
+# Key into the WSGI environment used for the experiment ID.
+WSGI_ENVIRON_KEY = "HTTP_TENSORBOARD_EXPERIMENT_ID"
+
+
+class ExperimentIdMiddleware:
+    """WSGI middleware extracting experiment IDs from URL to environment.
+
+    Any request whose path matches `/experiment/SOME_EID[/...]` will have
+    its first two path components stripped, and its experiment ID stored
+    onto the WSGI environment with key taken from the `WSGI_ENVIRON_KEY`
+    constant. All other requests will have paths unchanged and the
+    experiment ID set to the empty string. It noops if the key taken from
+    the `WSGI_ENVIRON_KEY` is already present in the environment.
+
+    Instances of this class are WSGI applications (see PEP 3333).
+    """
+
+    def __init__(self, application):
+        """Initializes an `ExperimentIdMiddleware`.
+
+        Args:
+          application: The WSGI application to wrap (see PEP 3333).
+        """
+        self._application = application
+        # Regular expression that matches the whole `/experiment/EID` prefix
+        # (without any trailing slash) and captures the experiment ID.
+        self._pat = re.compile(
+            r"/%s/([^/]*)" % re.escape(_EXPERIMENT_PATH_COMPONENT)
+        )
+
+    def __call__(self, environ, start_response):
+        # Skip ExperimentIdMiddleware was already called.
+        if WSGI_ENVIRON_KEY in environ:
+            return self._application(environ, start_response)
+
+        path = environ.get("PATH_INFO", "")
+        m = self._pat.match(path)
+        if m:
+            eid = m.group(1)
+            new_path = path[m.end(0) :]
+            root = m.group(0)
+        else:
+            eid = ""
+            new_path = path
+            root = ""
+        environ[WSGI_ENVIRON_KEY] = eid
+        environ["PATH_INFO"] = new_path
+        environ["SCRIPT_NAME"] = environ.get("SCRIPT_NAME", "") + root
+        return self._application(environ, start_response)

tensorbored/backend/experimental_plugin.py

@@ -0,0 +1,51 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Experimental plugin support for TensorBoard.
+
+Contains the mechanism for marking plugins as experimental.
+"""
+
+
+class ExperimentalPlugin:
+    """A marker class used to annotate a plugin as experimental.
+
+    Experimental plugins are hidden from users by default. The plugin will only
+    be enabled for a user if the user has specified the plugin with the
+    experimentalPlugin query parameter in the URL.
+
+    The marker class can annotate either TBPlugin or TBLoader instances, whichever
+    is most convenient.
+
+    Typical usage is to create a new class that inherits from both an existing
+    TBPlugin/TBLoader class and this marker class. For example:
+
+    class ExperimentalGraphsPlugin(
+        graphs_plugin.GraphsPlugin,
+        experimental_plugin.ExperimentalPlugin,
+    ):
+        pass
+
+
+    class ExperimentalDebuggerPluginLoader(
+        debugger_plugin_loader.DebuggerPluginLoader,
+        experimental_plugin.ExperimentalPlugin
+    ):
+        pass
+
+    Note: This class is itself an experimental mechanism and is subject to
+    modification or removal without warning.
+    """
+
+    pass

tensorbored/backend/http_util.py

@@ -0,0 +1,263 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""TensorBoard HTTP utilities."""
+
+import gzip
+import io
+import json
+import re
+import struct
+import time
+import wsgiref.handlers
+
+import werkzeug
+
+from tensorbored.backend import json_util
+
+_DISALLOWED_CHAR_IN_DOMAIN = re.compile(r"\s")
+
+# TODO(stephanwlee): Refactor this to not use the module variable but
+# instead use a configurable via some kind of assets provider which would
+# hold configurations for the CSP.
+
+# @vaadin/vaadin-lumo-styles/font-icons(via vaadin-grid) uses data URI for
+# loading font icons.
+_CSP_FONT_DOMAINS_WHITELIST = ["data:"]
+_CSP_FRAME_DOMAINS_WHITELIST = ["https://ui.perfetto.dev"]
+_CSP_IMG_DOMAINS_WHITELIST = []
+_CSP_SCRIPT_DOMAINS_WHITELIST = []
+_CSP_CONNECT_DOMAINS_WHITELIST = []
+_CSP_SCRIPT_SELF = True
+# numericjs (via projector) uses unsafe-eval :(.
+_CSP_SCRIPT_UNSAFE_EVAL = True
+_CSP_STYLE_DOMAINS_WHITELIST = []
+
+_EXTRACT_MIMETYPE_PATTERN = re.compile(r"^[^;\s]*")
+_EXTRACT_CHARSET_PATTERN = re.compile(r"charset=([-_0-9A-Za-z]+)")
+
+# Allows *, gzip or x-gzip, but forbid gzip;q=0
+# https://tools.ietf.org/html/rfc7231#section-5.3.4
+_ALLOWS_GZIP_PATTERN = re.compile(
+    r"(?:^|,|\s)(?:(?:x-)?gzip|\*)(?!;q=0)(?:\s|,|$)"
+)
+
+_TEXTUAL_MIMETYPES = set(
+    [
+        "application/javascript",
+        "application/json",
+        "application/json+protobuf",
+        "image/svg+xml",
+        "text/css",
+        "text/csv",
+        "text/html",
+        "text/javascript",
+        "text/plain",
+        "text/tab-separated-values",
+        "text/x-protobuf",
+    ]
+)
+
+_JSON_MIMETYPES = set(
+    [
+        "application/json",
+        "application/json+protobuf",
+    ]
+)
+
+# Do not support xhtml for now.
+_HTML_MIMETYPE = "text/html"
+
+
+def Respond(
+    request,
+    content,
+    content_type,
+    code=200,
+    expires=0,
+    content_encoding=None,
+    encoding="utf-8",
+    csp_scripts_sha256s=None,
+    headers=None,
+):
+    """Construct a werkzeug Response.
+
+    Responses are transmitted to the browser with compression if: a) the browser
+    supports it; b) it's sane to compress the content_type in question; and c)
+    the content isn't already compressed, as indicated by the content_encoding
+    parameter.
+
+    Browser and proxy caching is completely disabled by default. If the expires
+    parameter is greater than zero then the response will be able to be cached by
+    the browser for that many seconds; however, proxies are still forbidden from
+    caching so that developers can bypass the cache with Ctrl+Shift+R.
+
+    For textual content that isn't JSON, the encoding parameter is used as the
+    transmission charset which is automatically appended to the Content-Type
+    header. That is unless of course the content_type parameter contains a
+    charset parameter. If the two disagree, the characters in content will be
+    transcoded to the latter.
+
+    If content_type declares a JSON media type, then content MAY be a dict, list,
+    tuple, or set, in which case this function has an implicit composition with
+    json_util.Cleanse and json.dumps. The encoding parameter is used to decode
+    byte strings within the JSON object; therefore transmitting binary data
+    within JSON is not permitted. JSON is transmitted as ASCII unless the
+    content_type parameter explicitly defines a charset parameter, in which case
+    the serialized JSON bytes will use that instead of escape sequences.
+
+    Args:
+      request: A werkzeug Request object. Used mostly to check the
+        Accept-Encoding header.
+      content: Payload data as byte string, unicode string, or maybe JSON.
+      content_type: Media type and optionally an output charset.
+      code: Numeric HTTP status code to use.
+      expires: Second duration for browser caching.
+      content_encoding: Encoding if content is already encoded, e.g. 'gzip'.
+      encoding: Input charset if content parameter has byte strings.
+      csp_scripts_sha256s: List of base64 serialized sha256 of whitelisted script
+        elements for script-src of the Content-Security-Policy. If it is None, the
+        HTML will disallow any script to execute. It is only be used when the
+        content_type is text/html.
+      headers: Any additional headers to include on the response, as a
+        list of key-value tuples: e.g., `[("Allow", "GET")]`. In case of
+        conflict, these may be overridden with headers added by this function.
+
+    Returns:
+      A werkzeug Response object (a WSGI application).
+    """
+
+    mimetype = _EXTRACT_MIMETYPE_PATTERN.search(content_type).group(0)
+    charset_match = _EXTRACT_CHARSET_PATTERN.search(content_type)
+    charset = charset_match.group(1) if charset_match else encoding
+    textual = charset_match or mimetype in _TEXTUAL_MIMETYPES
+    if mimetype in _JSON_MIMETYPES and isinstance(
+        content, (dict, list, set, tuple)
+    ):
+        content = json.dumps(
+            json_util.Cleanse(content, encoding), ensure_ascii=not charset_match
+        )
+
+    # Ensure correct output encoding, transcoding if necessary.
+    if charset != encoding and isinstance(content, bytes):
+        content = content.decode(encoding)
+    if isinstance(content, str):
+        content = content.encode(charset)
+
+    if textual and not charset_match and mimetype not in _JSON_MIMETYPES:
+        content_type += "; charset=" + charset
+    gzip_accepted = _ALLOWS_GZIP_PATTERN.search(
+        request.headers.get("Accept-Encoding", "")
+    )
+    # Automatically gzip uncompressed text data if accepted.
+    if textual and not content_encoding and gzip_accepted:
+        out = io.BytesIO()
+        # Set mtime to zero to make payload for a given input deterministic.
+        with gzip.GzipFile(
+            fileobj=out, mode="wb", compresslevel=3, mtime=0
+        ) as f:
+            f.write(content)
+        content = out.getvalue()
+        content_encoding = "gzip"
+
+    content_length = len(content)
+    direct_passthrough = False
+    # Automatically streamwise-gunzip precompressed data if not accepted.
+    if content_encoding == "gzip" and not gzip_accepted:
+        gzip_file = gzip.GzipFile(fileobj=io.BytesIO(content), mode="rb")
+        # Last 4 bytes of gzip formatted data (little-endian) store the original
+        # content length mod 2^32; we just assume it's the content length. That
+        # means we can't streamwise-gunzip >4 GB precompressed file; this is ok.
+        content_length = struct.unpack("<I", content[-4:])[0]
+        content = werkzeug.wsgi.wrap_file(request.environ, gzip_file)
+        content_encoding = None
+        direct_passthrough = True
+
+    headers = list(headers or [])
+    headers.append(("Content-Length", str(content_length)))
+    headers.append(("X-Content-Type-Options", "nosniff"))
+    if content_encoding:
+        headers.append(("Content-Encoding", content_encoding))
+    if expires > 0:
+        e = wsgiref.handlers.format_date_time(time.time() + float(expires))
+        headers.append(("Expires", e))
+        headers.append(("Cache-Control", "private, max-age=%d" % expires))
+    else:
+        headers.append(("Expires", "0"))
+        headers.append(("Cache-Control", "no-cache, must-revalidate"))
+    if mimetype == _HTML_MIMETYPE:
+        frags = (
+            _CSP_SCRIPT_DOMAINS_WHITELIST
+            + [
+                "'self'" if _CSP_SCRIPT_SELF else "",
+                "'unsafe-eval'" if _CSP_SCRIPT_UNSAFE_EVAL else "",
+            ]
+            + [
+                "'sha256-{}'".format(sha256)
+                for sha256 in (csp_scripts_sha256s or [])
+            ]
+        )
+        script_srcs = _create_csp_string(*frags)
+
+        csp_string = ";".join(
+            [
+                "default-src 'self'",
+                "font-src %s"
+                % _create_csp_string("'self'", *_CSP_FONT_DOMAINS_WHITELIST),
+                # Dynamic plugins are rendered inside an iframe.
+                "frame-src %s"
+                % _create_csp_string("'self'", *_CSP_FRAME_DOMAINS_WHITELIST),
+                "img-src %s"
+                % _create_csp_string(
+                    "'self'",
+                    # used by favicon
+                    "data:",
+                    # used by What-If tool for image sprites.
+                    "blob:",
+                    *_CSP_IMG_DOMAINS_WHITELIST,
+                ),
+                "object-src 'none'",
+                "style-src %s"
+                % _create_csp_string(
+                    "'self'",
+                    # used by google-chart
+                    "https://www.gstatic.com",
+                    "data:",
+                    # inline styles: Polymer templates + d3 uses inline styles.
+                    "'unsafe-inline'",
+                    *_CSP_STYLE_DOMAINS_WHITELIST,
+                ),
+                "connect-src %s"
+                % _create_csp_string("'self'", *_CSP_CONNECT_DOMAINS_WHITELIST),
+                "script-src %s" % script_srcs,
+            ]
+        )
+
+        headers.append(("Content-Security-Policy", csp_string))
+
+    if request.method == "HEAD":
+        content = None
+
+    return werkzeug.wrappers.Response(
+        response=content,
+        status=code,
+        headers=headers,
+        content_type=content_type,
+        direct_passthrough=direct_passthrough,
+    )
+
+
+def _create_csp_string(*csp_fragments):
+    csp_string = " ".join([frag for frag in csp_fragments if frag])
+    return csp_string if csp_string else "'none'"