arize-phoenix 3.16.0__py3-none-any.whl → 7.7.0__py3-none-any.whl

phoenix/experimental/evals/templates/template.py

@@ -1,195 +0,0 @@
-import re
-from dataclasses import dataclass
-from typing import Callable, List, Mapping, Optional, Tuple, Union
-
-import pandas as pd
-
-from phoenix.exceptions import PhoenixException
-from phoenix.experimental.evals.utils import NOT_PARSABLE
-
-DEFAULT_START_DELIM = "{"
-DEFAULT_END_DELIM = "}"
-
-
-@dataclass
-class PromptOptions:
-    provide_explanation: bool = False
-
-
-class InvalidClassificationTemplateError(PhoenixException):
-    pass
-
-
-class PromptTemplate:
-    template: str
-    variables: List[str]
-
-    def __init__(
-        self,
-        template: str,
-        delimiters: Tuple[str, str] = (DEFAULT_START_DELIM, DEFAULT_END_DELIM),
-    ):
-        self.template = template
-        self._start_delim, self._end_delim = delimiters
-        self.variables = self._parse_variables(self.template)
-
-    def prompt(self, options: Optional[PromptOptions] = None) -> str:
-        return self.template
-
-    def format(
-        self,
-        variable_values: Mapping[str, Union[bool, int, float, str]],
-        options: Optional[PromptOptions] = None,
-    ) -> str:
-        prompt = self.prompt(options)
-        for variable_name in self.variables:
-            prompt = prompt.replace(
-                self._start_delim + variable_name + self._end_delim,
-                str(variable_values[variable_name]),
-            )
-        return prompt
-
-    def _parse_variables(self, text: str) -> List[str]:
-        pattern = re.escape(self._start_delim) + "(.*?)" + re.escape(self._end_delim)
-        variables = re.findall(pattern, text)
-        return variables
-
-
-class ClassificationTemplate(PromptTemplate):
-    def __init__(
-        self,
-        rails: List[str],
-        template: str,
-        explanation_template: Optional[str] = None,
-        explanation_label_parser: Optional[Callable[[str], str]] = None,
-        delimiters: Tuple[str, str] = (DEFAULT_START_DELIM, DEFAULT_END_DELIM),
-        scores: Optional[List[float]] = None,
-    ):
-        if scores is not None and len(rails) != len(scores):
-            raise InvalidClassificationTemplateError(
-                "If scores are provided, each rail must have one and only one score "
-                "(i.e., the length of both lists must be the same)."
-            )
-        self.rails = rails
-        self.template = template
-        self.explanation_template = explanation_template
-        self.explanation_label_parser = explanation_label_parser
-        self._start_delim, self._end_delim = delimiters
-        self.variables: List[str] = []
-        for text in [template, explanation_template]:
-            if text is not None:
-                self.variables += self._parse_variables(text)
-        self._scores = scores
-
-    def __repr__(self) -> str:
-        return self.template
-
-    def prompt(self, options: Optional[PromptOptions] = None) -> str:
-        if options is None:
-            return self.template
-
-        if options.provide_explanation and self.explanation_template:
-            return self.explanation_template
-        else:
-            return self.template
-
-    def extract_label_from_explanation(self, raw_string: str) -> str:
-        if parser := self.explanation_label_parser:
-            return parser(raw_string)
-        return parse_label_from_chain_of_thought_response(raw_string)
-
-    def score(self, rail: str) -> float:
-        if self._scores is None:
-            return 0.0
-        try:
-            return self._scores[self.rails.index(rail)]
-        except (IndexError, ValueError):
-            return 0.0
-
-
-def parse_label_from_chain_of_thought_response(raw_string: str) -> str:
-    label_delimiter = r"\W*label\W*"
-    parts = re.split(label_delimiter, raw_string, maxsplit=1, flags=re.IGNORECASE)
-    if len(parts) == 2:
-        return parts[1]
-    return NOT_PARSABLE
-
-
-def normalize_classification_template(
-    rails: List[str], template: Union[PromptTemplate, ClassificationTemplate, str]
-) -> ClassificationTemplate:
-    """
-    Normalizes a template to a ClassificationTemplate object.
-    Args:
-        template (Union[ClassificationTemplate, str]): The template to be normalized.
-    Returns:
-        ClassificationTemplate: The normalized template.
-    """
-    if isinstance(template, ClassificationTemplate):
-        return template
-
-    if isinstance(template, PromptTemplate):
-        return ClassificationTemplate(rails=rails, template=template.template)
-
-    if isinstance(template, str):
-        return ClassificationTemplate(rails=rails, template=template)
-
-    raise TypeError(
-        "Invalid type for argument `template`. Expected a string or ClassificationTemplate "
-        f"but found {type(template)}."
-    )
-
-
-def normalize_prompt_template(template: Union[PromptTemplate, str]) -> PromptTemplate:
-    """
-    Normalizes a template to a PromptTemplate object.
-    Args:
-        template (Union[PromptTemplate, str]): The template to be normalized.
-    Returns:
-        PromptTemplate: The normalized template.
-    """
-    if isinstance(template, PromptTemplate):
-        return template
-
-    if isinstance(template, str):
-        return PromptTemplate(template=template)
-
-    raise TypeError(
-        "Invalid type for argument `template`. Expected a string or PromptTemplate "
-        f"but found {type(template)}."
-    )
-
-
-def map_template(
-    dataframe: pd.DataFrame,
-    template: PromptTemplate,
-    options: Optional[PromptOptions] = None,
-) -> "pd.Series[str]":
-    """
-    Maps over a dataframe to construct a list of prompts from a template and a dataframe.
-    """
-    # Was considering to construct the prompts and generate answers concurrently. However,
-    # if there's errors in the prompt construction it could interrupt the process and we
-    # would've used API credits for nothing. We could solve this problem by streaming the
-    # answers so that, if there is an error, we keep the answers obtained up to that point.
-    # These are out of scope for M0, but good to keep in mind and consider for the future.
-    prompt_options: PromptOptions = PromptOptions() if options is None else options
-
-    try:
-        prompts = dataframe.apply(
-            lambda row: template.format(
-                variable_values={var_name: row[var_name] for var_name in template.variables},
-                options=prompt_options,
-            ),
-            axis=1,
-        )
-        return prompts
-    except KeyError as e:
-        raise RuntimeError(
-            f"Error while constructing the prompts from the template and dataframe. "
-            f"The template variable {e} is not found as a column in the dataframe."
-        )
-    except Exception as e:
-        raise RuntimeError(
-            f"Error while constructing the prompts from the template and dataframe variables: {e}."
-        )

phoenix/experimental/evals/utils/__init__.py

@@ -1,172 +0,0 @@
-import json
-from io import BytesIO
-from typing import Any, Dict, List, Optional, Tuple
-from urllib.error import HTTPError
-from urllib.request import urlopen
-from zipfile import ZipFile
-
-import pandas as pd
-
-from phoenix.utilities.logging import printif
-
-# Rather than returning None, we return this string to indicate that the LLM output could not be
-# parsed.
-# This is useful for debugging as well as to just treat the output as a non-parsable category
-NOT_PARSABLE = "NOT_PARSABLE"
-
-# values in the default openai function call,
-# defined here only to prevent typos
-_RESPONSE = "response"
-_EXPLANATION = "explanation"
-_FUNCTION_NAME = "record_response"
-
-
-def download_benchmark_dataset(task: str, dataset_name: str) -> pd.DataFrame:
-    """Downloads an Arize evals benchmark dataset as a pandas dataframe.
-
-    Args:
-        task (str): Task to be performed.
-        dataset_name (str): Name of the dataset.
-
-    Returns:
-        pandas.DataFrame: A pandas dataframe containing the data.
-    """
-    jsonl_file_name = f"{dataset_name}.jsonl"
-    url = f"http://storage.googleapis.com/arize-phoenix-assets/evals/{task}/{jsonl_file_name}.zip"
-    try:
-        with urlopen(url) as response:
-            zip_byte_stream = BytesIO(response.read())
-            with ZipFile(zip_byte_stream) as zip_file:
-                with zip_file.open(jsonl_file_name) as jsonl_file:
-                    return pd.DataFrame(map(json.loads, jsonl_file.readlines()))
-    except HTTPError:
-        raise ValueError(f'Dataset "{dataset_name}" for "{task}" task does not exist.')
-
-
-def get_tqdm_progress_bar_formatter(title: str) -> str:
-    """Returns a progress bar formatter for use with tqdm.
-
-    Args:
-        title (str): The title of the progress bar, displayed as a prefix.
-
-    Returns:
-        str: A formatter to be passed to the bar_format argument of tqdm.
-    """
-    return (
-        title + " |{bar}| {n_fmt}/{total_fmt} ({percentage:3.1f}%) "
-        "| ⏳ {elapsed}<{remaining} | {rate_fmt}{postfix}"
-    )
-
-
-def snap_to_rail(raw_string: Optional[str], rails: List[str], verbose: bool = False) -> str:
-    """
-    Snaps a string to the nearest rail, or returns None if the string cannot be
-    snapped to a rail.
-
-    Args:
-        raw_string (str): An input to be snapped to a rail.
-
-        rails (List[str]): The target set of strings to snap to.
-
-    Returns:
-        str: A string from the rails argument or "UNPARSABLE" if the input
-        string could not be snapped.
-    """
-    if not raw_string:
-        return NOT_PARSABLE
-    snap_string = raw_string.lower()
-    rails = list(set(rail.lower() for rail in rails))
-    rails.sort(key=len, reverse=True)
-    found_rails = set()
-    for rail in rails:
-        if rail in snap_string:
-            found_rails.add(rail)
-            snap_string = snap_string.replace(rail, "")
-    if len(found_rails) != 1:
-        printif(verbose, f"- Cannot snap {repr(raw_string)} to rails")
-        return NOT_PARSABLE
-    rail = list(found_rails)[0]
-    printif(verbose, f"- Snapped {repr(raw_string)} to rail: {rail}")
-    return rail
-
-
-def parse_openai_function_call(raw_output: str) -> Tuple[str, Optional[str]]:
-    """
-    Parses the output of an OpenAI function call.
-
-    Args:
-        raw_output (str): The raw output of an OpenAI function call.
-
-    Returns:
-        Tuple[str, Optional[str]]: A tuple of the unrailed label and an optional
-        explanation.
-    """
-    try:
-        function_arguments = json.loads(raw_output, strict=False)
-        unrailed_label = function_arguments.get(_RESPONSE, "")
-        explanation = function_arguments.get(_EXPLANATION)
-    except json.JSONDecodeError:
-        unrailed_label = raw_output
-        explanation = None
-    return unrailed_label, explanation
-
-
-def openai_function_call_kwargs(rails: List[str], provide_explanation: bool) -> Dict[str, Any]:
-    """
-    Returns keyword arguments needed to invoke an OpenAI model with function
-    calling for classification.
-
-    Args:
-        rails (List[str]): The rails to snap the output to.
-
-        provide_explanation (bool): Whether to provide an explanation.
-
-    Returns:
-        Dict[str, Any]: A dictionary containing function call arguments.
-    """
-    openai_function = _default_openai_function(rails, provide_explanation)
-    return {
-        "functions": [openai_function],
-        "function_call": {"name": openai_function["name"]},
-    }
-
-
-def _default_openai_function(
-    rails: List[str],
-    with_explanation: bool = False,
-) -> Dict[str, Any]:
-    """
-    Returns a default OpenAI function call for classification.
-
-    Args:
-        rails (List[str]): A list of rails to snap the output to.
-
-        with_explanation (bool, optional): Whether to include an explanation.
-
-    Returns:
-        Dict[str, Any]: A JSON schema object advertising a function to record
-        the result of the LLM's classification.
-    """
-    properties = {
-        **(
-            {
-                _EXPLANATION: {
-                    "type": "string",
-                    "description": "Explanation of the reasoning for your response.",
-                },
-            }
-            if with_explanation
-            else {}
-        ),
-        _RESPONSE: {"type": "string", "description": "Your response.", "enum": rails},
-    }
-    required = [*([_EXPLANATION] if with_explanation else []), _RESPONSE]
-    return {
-        "name": _FUNCTION_NAME,
-        "description": "A function to record your response.",
-        "parameters": {
-            "type": "object",
-            "properties": properties,
-            "required": required,
-        },
-    }

phoenix/experimental/evals/utils/threads.py

@@ -1,27 +0,0 @@
-"""High-level support for working with threads in asyncio
-Directly copied from: https://github.com/python/cpython/blob/main/Lib/asyncio/threads.py#L12
-since this helper function 'to_thread' is not available in python<3.9
-"""
-
-import contextvars
-import functools
-from asyncio import events
-from typing import Any
-
-__all__ = ("to_thread",)
-
-
-async def to_thread(func, /, *args, **kwargs) -> Any:  # type:ignore
-    """Asynchronously run function *func* in a separate thread.
-
-    Any *args and **kwargs supplied for this function are directly passed
-    to *func*. Also, the current :class:`contextvars.Context` is propagated,
-    allowing context variables from the main thread to be accessed in the
-    separate thread.
-
-    Return a coroutine that can be awaited to get the eventual result of *func*.
-    """
-    loop = events.get_running_loop()
-    ctx = contextvars.copy_context()
-    func_call = functools.partial(ctx.run, func, *args, **kwargs)
-    return await loop.run_in_executor(None, func_call)

phoenix/server/api/helpers.py

@@ -1,11 +0,0 @@
-from typing import Iterable, List, Optional, TypeVar
-
-T = TypeVar("T")
-
-
-def ensure_list(obj: Optional[Iterable[T]]) -> List[T]:
-    if isinstance(obj, List):
-        return obj
-    if isinstance(obj, Iterable):
-        return list(obj)
-    return []

phoenix/server/api/routers/evaluation_handler.py

@@ -1,109 +0,0 @@
-import asyncio
-import gzip
-from typing import AsyncIterator
-
-import pyarrow as pa
-from google.protobuf.message import DecodeError
-from starlette.background import BackgroundTask
-from starlette.endpoints import HTTPEndpoint
-from starlette.requests import Request
-from starlette.responses import Response, StreamingResponse
-from starlette.status import (
-    HTTP_404_NOT_FOUND,
-    HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-)
-
-import phoenix.trace.v1 as pb
-from phoenix.config import DEFAULT_PROJECT_NAME
-from phoenix.core.traces import Traces
-from phoenix.server.api.routers.utils import table_to_bytes
-from phoenix.session.evaluation import encode_evaluations
-from phoenix.trace.span_evaluations import Evaluations
-
-
-class EvaluationHandler(HTTPEndpoint):
-    traces: Traces
-
-    async def post(self, request: Request) -> Response:
-        content_type = request.headers.get("content-type")
-        project_name = request.headers.get("project-name", DEFAULT_PROJECT_NAME)
-        if content_type == "application/x-pandas-arrow":
-            return await self._process_pyarrow(request)
-        if content_type != "application/x-protobuf":
-            return Response(
-                content="Unsupported content type",
-                status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-            )
-        body = await request.body()
-        content_encoding = request.headers.get("content-encoding")
-        if content_encoding == "gzip":
-            body = gzip.decompress(body)
-        elif content_encoding:
-            return Response(
-                content="Unsupported content encoding",
-                status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-            )
-        evaluation = pb.Evaluation()
-        try:
-            evaluation.ParseFromString(body)
-        except DecodeError:
-            return Response(
-                content="Request body is invalid",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            )
-        self.traces.put(evaluation, project_name=project_name)
-        return Response()
-
-    async def get(self, request: Request) -> Response:
-        payload = await request.json()
-        project_name = payload.pop("project_name", None) or DEFAULT_PROJECT_NAME
-        project = self.traces.get_project(project_name)
-        if not project:
-            return Response(status_code=HTTP_404_NOT_FOUND)
-        loop = asyncio.get_running_loop()
-        results = await loop.run_in_executor(
-            None,
-            project.export_evaluations,
-        )
-        if not results:
-            return Response(status_code=HTTP_404_NOT_FOUND)
-
-        async def content() -> AsyncIterator[bytes]:
-            for result in results:
-                yield await loop.run_in_executor(
-                    None,
-                    lambda: table_to_bytes(result.to_pyarrow_table()),
-                )
-
-        return StreamingResponse(
-            content=content(),
-            media_type="application/x-pandas-arrow",
-        )
-
-    async def _process_pyarrow(self, request: Request) -> Response:
-        body = await request.body()
-        try:
-            reader = pa.ipc.open_stream(body)
-        except pa.ArrowInvalid:
-            return Response(
-                content="Request body is not valid pyarrow",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            )
-        try:
-            evaluations = Evaluations.from_pyarrow_reader(reader)
-        except Exception:
-            return Response(
-                content="Invalid data in request body",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            )
-        return Response(
-            background=BackgroundTask(
-                self._add_evaluations,
-                evaluations,
-            )
-        )
-
-    async def _add_evaluations(self, evaluations: Evaluations) -> None:
-        for evaluation in encode_evaluations(evaluations):
-            self.traces.put(evaluation)

phoenix/server/api/routers/span_handler.py

@@ -1,70 +0,0 @@
-import asyncio
-from functools import partial
-from typing import AsyncIterator
-
-from starlette.endpoints import HTTPEndpoint
-from starlette.requests import Request
-from starlette.responses import Response, StreamingResponse
-from starlette.status import HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY
-
-from phoenix.config import DEFAULT_PROJECT_NAME
-from phoenix.core.traces import Traces
-from phoenix.server.api.routers.utils import df_to_bytes, from_iso_format
-from phoenix.trace.dsl import SpanQuery
-from phoenix.utilities import query_spans
-
-
-class SpanHandler(HTTPEndpoint):
-    traces: Traces
-
-    async def get(self, request: Request) -> Response:
-        payload = await request.json()
-        queries = payload.pop("queries", [])
-        project_name = payload.pop("project_name", None) or DEFAULT_PROJECT_NAME
-        if not (project := self.traces.get_project(project_name)):
-            return Response(status_code=HTTP_404_NOT_FOUND)
-        loop = asyncio.get_running_loop()
-        valid_eval_names = (
-            await loop.run_in_executor(
-                None,
-                project.get_span_evaluation_names,
-            )
-            if project
-            else ()
-        )
-        try:
-            span_queries = [
-                SpanQuery.from_dict(
-                    query,
-                    evals=project,
-                    valid_eval_names=valid_eval_names,
-                )
-                for query in queries
-            ]
-        except Exception as e:
-            return Response(
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-                content=f"Invalid query: {e}",
-            )
-        results = await loop.run_in_executor(
-            None,
-            partial(
-                query_spans,
-                project,
-                *span_queries,
-                start_time=from_iso_format(payload.get("start_time")),
-                stop_time=from_iso_format(payload.get("stop_time")),
-                root_spans_only=payload.get("root_spans_only"),
-            ),
-        )
-        if not results:
-            return Response(status_code=HTTP_404_NOT_FOUND)
-
-        async def content() -> AsyncIterator[bytes]:
-            for result in results:
-                yield df_to_bytes(result)
-
-        return StreamingResponse(
-            content=content(),
-            media_type="application/x-pandas-arrow",
-        )

phoenix/server/api/routers/trace_handler.py

@@ -1,60 +0,0 @@
-import asyncio
-import gzip
-import zlib
-from typing import Optional
-
-from google.protobuf.message import DecodeError
-from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import (
-    ExportTraceServiceRequest,
-)
-from opentelemetry.proto.trace.v1.trace_pb2 import TracesData
-from starlette.endpoints import HTTPEndpoint
-from starlette.requests import Request
-from starlette.responses import Response
-from starlette.status import HTTP_415_UNSUPPORTED_MEDIA_TYPE, HTTP_422_UNPROCESSABLE_ENTITY
-
-from phoenix.core.traces import Traces
-from phoenix.storage.span_store import SpanStore
-from phoenix.trace.otel import decode
-from phoenix.utilities.project import get_project_name
-
-
-class TraceHandler(HTTPEndpoint):
-    traces: Traces
-    store: Optional[SpanStore]
-
-    async def post(self, request: Request) -> Response:
-        content_type = request.headers.get("content-type")
-        if content_type != "application/x-protobuf":
-            return Response(
-                content=f"Unsupported content type: {content_type}",
-                status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-            )
-        content_encoding = request.headers.get("content-encoding")
-        if content_encoding and content_encoding not in ("gzip", "deflate"):
-            return Response(
-                content=f"Unsupported content encoding: {content_encoding}",
-                status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-            )
-        body = await request.body()
-        if content_encoding == "gzip":
-            body = gzip.decompress(body)
-        elif content_encoding == "deflate":
-            body = zlib.decompress(body)
-        req = ExportTraceServiceRequest()
-        try:
-            req.ParseFromString(body)
-        except DecodeError:
-            return Response(
-                content="Request body is invalid ExportTraceServiceRequest",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            )
-        if self.store:
-            self.store.save(TracesData(resource_spans=req.resource_spans))
-        for resource_spans in req.resource_spans:
-            project_name = get_project_name(resource_spans.resource.attributes)
-            for scope_span in resource_spans.scope_spans:
-                for span in scope_span.spans:
-                    self.traces.put(decode(span), project_name=project_name)
-                    await asyncio.sleep(0)
-        return Response()

phoenix/server/api/types/DatasetRole.py

@@ -1,23 +0,0 @@
-from enum import Enum
-from typing import Dict, Union
-
-import strawberry
-
-from phoenix.core.model_schema import PRIMARY, REFERENCE
-
-
-@strawberry.enum
-class DatasetRole(Enum):
-    primary = PRIMARY
-    reference = REFERENCE
-
-
-class AncillaryDatasetRole(Enum):
-    corpus = "DatasetRole.CORPUS"
-
-
-STR_TO_DATASET_ROLE: Dict[str, Union[DatasetRole, AncillaryDatasetRole]] = {
-    str(DatasetRole.primary.value): DatasetRole.primary,
-    str(DatasetRole.reference.value): DatasetRole.reference,
-    str(AncillaryDatasetRole.corpus.value): AncillaryDatasetRole.corpus,
-}

phoenix/server/static/index.css

@@ -1,6 +0,0 @@
-html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{-webkit-appearance:button}button::-moz-focus-inner,[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}template{display:none}[hidden]{display:none}
-/*! Bundled license information:
-
-normalize.css/normalize.css:
-  (*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css *)
-*/