flyte 0.1.0__py3-none-any.whl → 0.2.0a0__py3-none-any.whl

flyte/types/_renderer.py

@@ -0,0 +1,162 @@
+from typing import TYPE_CHECKING, Any
+
+from markdown_it import MarkdownIt
+from typing_extensions import Protocol, runtime_checkable
+
+from flyte._utils import lazy_module
+
+if TYPE_CHECKING:
+    # Always import these modules in type-checking mode or when running pytest
+    import pandas
+    import pyarrow
+else:
+    pandas = lazy_module("pandas")
+    pyarrow = lazy_module("pyarrow")
+
+
+@runtime_checkable
+class Renderable(Protocol):
+    def to_html(self, python_value: Any) -> str:
+        """Convert an object(markdown, pandas.dataframe) to HTML and return HTML as a unicode string.
+        Returns: An HTML document as a string.
+        """
+        raise NotImplementedError
+
+
+DEFAULT_MAX_ROWS = 10
+DEFAULT_MAX_COLS = 100
+
+
+class TopFrameRenderer:
+    """
+    Render a DataFrame as an HTML table.
+    """
+
+    def __init__(self, max_rows: int = DEFAULT_MAX_ROWS, max_cols: int = DEFAULT_MAX_COLS):
+        self._max_rows = max_rows
+        self._max_cols = max_cols
+
+    def to_html(self, df: "pandas.DataFrame") -> str:
+        assert isinstance(df, pandas.DataFrame)
+        return df.to_html(max_rows=self._max_rows, max_cols=self._max_cols)
+
+
+class ArrowRenderer:
+    """
+    Render an Arrow dataframe as an HTML table.
+    """
+
+    def to_html(self, df: "pyarrow.Table") -> str:
+        assert isinstance(df, pyarrow.Table)
+        return df.to_string()
+
+
+class MarkdownRenderer:
+    """Convert a markdown string to HTML and return HTML as a unicode string."""
+
+    def to_html(self, text: str) -> str:
+        return MarkdownIt().render(text)
+
+
+class SourceCodeRenderer:
+    """
+    Convert Python source code to HTML, and return HTML as a unicode string.
+    """
+
+    def __init__(self, title: str = "Source Code"):
+        self._title = title
+
+    def to_html(self, source_code: str) -> str:
+        """
+        Convert the provided Python source code into HTML format using Pygments library.
+
+        This method applies a colorful style and replaces the color "#fff0f0" with "#ffffff" in CSS.
+
+        Args:
+            source_code (str): The Python source code to be converted.
+
+        Returns:
+            str: The resulting HTML as a string, including CSS and highlighted source code.
+        """
+        from pygments import highlight
+        from pygments.formatters.html import HtmlFormatter
+        from pygments.lexers.python import PythonLexer
+
+        formatter = HtmlFormatter(style="colorful")
+        css = formatter.get_style_defs(".highlight").replace("#fff0f0", "#ffffff")
+        html = highlight(source_code, PythonLexer(), formatter)
+        return f"<style>{css}</style>{html}"
+
+
+class PythonDependencyRenderer:
+    """
+    PythonDependencyDeck is a deck that contains information about packages installed via pip.
+    """
+
+    def __init__(self, title: str = "Dependencies"):
+        self._title = title
+
+    def to_html(self) -> str:
+        import json
+        import subprocess
+        import sys
+
+        from flytekit.loggers import logger
+
+        try:
+            installed_packages = json.loads(
+                subprocess.check_output([sys.executable, "-m", "pip", "list", "--format", "json"])
+            )
+            requirements_txt = (
+                subprocess.check_output([sys.executable, "-m", "pip", "freeze"])
+                .decode("utf-8")
+                .replace("\\n", "\n")
+                .rstrip()
+            )
+        except Exception as e:
+            logger.error(f"Error occurred while fetching installed packages: {e}")
+            return "Error occurred while fetching installed packages."
+
+        table = (
+            "<table>\n<tr>\n<th style='text-align:left;'>Name</th>\n<th style='text-align:left;'>Version</th>\n</tr>\n"
+        )
+
+        for entry in installed_packages:
+            table += f"<tr>\n<td>{entry['name']}</td>\n<td>{entry['version']}</td>\n</tr>\n"
+
+        table += "</table>"
+
+        html = f"""
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Flyte Dependencies</title>
+        <script>
+        async function copyTable() {{
+          var requirements_txt = document.getElementById('requirements_txt');
+
+          try {{
+            await navigator.clipboard.writeText(requirements_txt.innerText);
+          }} catch (err) {{
+            console.log('Error accessing the clipboard: ' + err);
+          }}
+        }}
+        </script>
+        </head>
+        <body>
+
+        <button onclick="copyTable()">
+          <span>Copy table as requirements.txt</span>
+        </button>
+        <h3>Python Dependencies</h3>
+
+        {table}
+
+        <div id="requirements_txt" style="display:none">{requirements_txt}</div>
+
+        </body>
+        </html>
+        """
+        return html

flyte/types/_string_literals.py

@@ -0,0 +1,120 @@
+import base64
+import json
+from typing import Any, Dict, Union
+
+import msgpack
+from flyteidl.core import literals_pb2
+from google.protobuf.json_format import MessageToDict
+
+from flyte._protos.workflow import run_definition_pb2
+
+
+def _primitive_to_string(primitive: literals_pb2.Primitive) -> Any:
+    """
+    This method is used to convert a primitive to a string representation.
+    """
+    match primitive.WhichOneof("value"):
+        case "integer":
+            return primitive.integer
+        case "float_value":
+            return primitive.float_value
+        case "boolean":
+            return primitive.boolean
+        case "string_value":
+            return primitive.string_value
+        case "datetime":
+            return primitive.datetime.ToDatetime().isoformat()
+        case "duration":
+            return primitive.duration.ToSeconds()
+        case _:
+            raise ValueError(f"Unknown primitive type {primitive}")
+
+
+def _scalar_to_string(scalar: literals_pb2.Scalar) -> Any:
+    """
+    This method is used to convert a scalar to a string representation.
+    """
+    match scalar.WhichOneof("value"):
+        case "primitive":
+            return _primitive_to_string(scalar.primitive)
+        case "none_type":
+            return None
+        case "error":
+            return scalar.error.message
+        case "structured_dataset":
+            return scalar.structured_dataset.uri
+        case "schema":
+            return scalar.schema.uri
+        case "blob":
+            return scalar.blob.uri
+        case "binary":
+            if scalar.binary.tag == "msgpack":
+                return json.dumps(msgpack.unpackb(scalar.binary.value))
+            return base64.b64encode(scalar.binary.value)
+        case "generic":
+            return MessageToDict(scalar.generic)
+        case "union":
+            return _literal_string_repr(scalar.union.value)
+        case _:
+            raise ValueError(f"Unknown scalar type {scalar}")
+
+
+def _literal_string_repr(lit: literals_pb2.Literal) -> Any:
+    """
+    This method is used to convert a literal to a string representation. This is useful in places, where we need to
+    use a shortened string representation of a literal, especially a FlyteFile, FlyteDirectory, or StructuredDataset.
+    """
+    match lit.WhichOneof("value"):
+        case "scalar":
+            return _scalar_to_string(lit.scalar)
+        case "collection":
+            return [literal_string_repr(i) for i in lit.collection.literals]
+        case "map":
+            return {k: literal_string_repr(v) for k, v in lit.map.literals.items()}
+        case "offloaded_metadata":
+            # TODO: load literal from offloaded literal?
+            return f"Offloaded literal metadata: {lit.offloaded_metadata}"
+        case _:
+            raise ValueError(f"Unknown literal type {lit}")
+
+
+def _dict_literal_repr(lmd: Dict[str, literals_pb2.Literal]) -> Dict[str, Any]:
+    """
+    This method is used to convert a literal map to a string representation.
+    """
+    return {k: _literal_string_repr(v) for k, v in lmd.items()}
+
+
+def literal_string_repr(
+    lm: Union[
+        literals_pb2.Literal,
+        run_definition_pb2.NamedLiteral,
+        run_definition_pb2.Inputs,
+        run_definition_pb2.Outputs,
+        literals_pb2.LiteralMap,
+        Dict[str, literals_pb2.Literal],
+    ],
+) -> Dict[str, Any]:
+    """
+    This method is used to convert a literal map to a string representation.
+    """
+    if lm is None:
+        return {}
+    match lm:
+        case literals_pb2.Literal():
+            return _literal_string_repr(lm)
+        case literals_pb2.LiteralMap():
+            return _dict_literal_repr(lm.literals)
+        case run_definition_pb2.NamedLiteral():
+            lmd = {lm.name: lm.value}
+            return _dict_literal_repr(lmd)
+        case run_definition_pb2.Inputs():
+            lmd = {n.name: n.value for n in lm.literals}
+            return _dict_literal_repr(lmd)
+        case run_definition_pb2.Outputs():
+            lmd = {n.name: n.value for n in lm.literals}
+            return _dict_literal_repr(lmd)
+        case dict():
+            return _dict_literal_repr(lm)
+        case _:
+            raise ValueError(f"Unknown literal type {lm}, type{type(lm)}")