pixeltable 0.2.28__py3-none-any.whl → 0.2.30__py3-none-any.whl

pixeltable/tool/doc_plugins/griffe.py

@@ -1,50 +0,0 @@
-import ast
-import warnings
-from typing import Optional, Union
-
-import griffe
-import griffe.expressions
-from griffe import Extension, Object, ObjectNode
-
-import pixeltable as pxt
-
-logger = griffe.get_logger(__name__)
-
-class PxtGriffeExtension(Extension):
-    """Implementation of a Pixeltable custom griffe extension."""
-
-    def on_instance(self, node: Union[ast.AST, ObjectNode], obj: Object) -> None:
-        if obj.docstring is None:
-            # Skip over entities without a docstring
-            return
-
-        if isinstance(obj, griffe.Function):
-            # See if the (Python) function has a @pxt.udf decorator
-            if any(
-                isinstance(dec.value, griffe.expressions.Expr) and dec.value.canonical_path in ['pixeltable.func.udf', 'pixeltable.udf']
-                for dec in obj.decorators
-            ):
-                # Update the template
-                self.__modify_pxt_udf(obj)
-
-    def __modify_pxt_udf(self, func: griffe.Function) -> None:
-        """
-        Instructs the doc snippet for `func` to use the custom Pixeltable UDF jinja template, and
-        converts all type hints to Pixeltable column type references, in accordance with the @udf
-        decorator behavior.
-        """
-        func.extra['mkdocstrings']['template'] = 'udf.html.jinja'
-        # Dynamically load the UDF reference so we can inspect the Pixeltable signature directly
-        warnings.simplefilter("ignore")
-        udf = griffe.dynamic_import(func.path)
-        assert isinstance(udf, pxt.Function)
-        # Convert the return type to a Pixeltable type reference
-        func.returns = str(udf.signature.get_return_type())
-        # Convert the parameter types to Pixeltable type references
-        for griffe_param in func.parameters:
-            assert isinstance(griffe_param.annotation, griffe.expressions.Expr)
-            if griffe_param.name not in udf.signature.parameters:
-                logger.warning(f'Parameter `{griffe_param.name}` not found in signature for UDF: {udf.display_name}')
-                continue
-            pxt_param = udf.signature.parameters[griffe_param.name]
-            griffe_param.annotation = str(pxt_param.col_type)

pixeltable/tool/doc_plugins/mkdocstrings.py

@@ -1,6 +0,0 @@
-from pathlib import Path
-
-
-def get_templates_path() -> Path:
-    """Implementation of the 'mkdocstrings.python.templates' plugin for custom jinja templates."""
-    return Path(__file__).parent / "templates"

pixeltable/tool/doc_plugins/templates/material/udf.html.jinja

@@ -1,135 +0,0 @@
-{#- Template for Pixeltable UDFs. Cargo-culted (with modification) from _base/function.html.jinja. -#}
-
-{% block logs scoped %}
-  {#- Logging block.
-
-  This block can be used to log debug messages, deprecation messages, warnings, etc.
-  -#}
-  {{ log.debug("Rendering " + function.path) }}
-{% endblock logs %}
-
-{% import "language"|get_template as lang with context %}
-{#- Language module providing the `t` translation method. -#}
-
-<div class="doc doc-object doc-function">
-  {% with obj = function, html_id = function.path %}
-
-    {% if root %}
-      {% set show_full_path = config.show_root_full_path %}
-      {% set root_members = True %}
-    {% elif root_members %}
-      {% set show_full_path = config.show_root_members_full_path or config.show_object_full_path %}
-      {% set root_members = False %}
-    {% else %}
-      {% set show_full_path = config.show_object_full_path %}
-    {% endif %}
-
-    {% set function_name = function.path if show_full_path else function.name %}
-    {#- Brief or full function name depending on configuration. -#}
-    {% set symbol_type = "udf" %}
-    {#- Symbol type: method when parent is a class, function otherwise. -#}
-
-    {% if not root or config.show_root_heading %}
-      {% filter heading(
-          heading_level,
-          role="function",
-          id=html_id,
-          class="doc doc-heading",
-          toc_label=(('<code class="doc-symbol doc-symbol-toc doc-symbol-' + symbol_type + '"></code>&nbsp;')|safe if config.show_symbol_type_toc else '') + function.name,
-        ) %}
-
-        {% block heading scoped %}
-          {#- Heading block.
-
-          This block renders the heading for the function.
-          -#}
-          {% if config.show_symbol_type_heading %}<code class="doc-symbol doc-symbol-heading doc-symbol-{{ symbol_type }}"></code>{% endif %}
-          {% if config.separate_signature %}
-            <span class="doc doc-object-name doc-function-name">{{ function_name }}</span>
-          {% else %}
-            {%+ filter highlight(language="python", inline=True) %}
-              {{ function_name }}{% include "signature"|get_template with context %}
-            {% endfilter %}
-          {% endif %}
-        {% endblock heading %}
-
-        {% block labels scoped %}
-          {#- Labels block.
-
-          This block renders the labels for the function.
-          -#}
-          {% with labels = function.labels %}
-            {% include "labels"|get_template with context %}
-          {% endwith %}
-        {% endblock labels %}
-
-      {% endfilter %}
-
-      {% block signature scoped %}
-        {#- Signature block.
-
-        This block renders the signature for the function.
-        -#}
-        {% if config.separate_signature %}
-          {% filter format_signature(function, config.line_length, crossrefs=config.signature_crossrefs) %}
-            {{ function.name }}
-          {% endfilter %}
-        {% endif %}
-      {% endblock signature %}
-
-    {% else %}
-
-      {% if config.show_root_toc_entry %}
-        {% filter heading(
-            heading_level,
-            role="function",
-            id=html_id,
-            toc_label=(('<code class="doc-symbol doc-symbol-toc doc-symbol-' + symbol_type + '"></code>&nbsp;')|safe if config.show_symbol_type_toc else '') + function.name,
-            hidden=True,
-          ) %}
-        {% endfilter %}
-      {% endif %}
-      {% set heading_level = heading_level - 1 %}
-    {% endif %}
-
-    <div class="doc doc-contents {% if root %}first{% endif %}">
-      {% block contents scoped %}
-        {#- Contents block.
-
-        This block renders the contents of the function.
-        It contains other blocks that users can override.
-        Overriding the contents block allows to rearrange the order of the blocks.
-        -#}
-        {% block docstring scoped %}
-          {#- Docstring block.
-
-          This block renders the docstring for the function.
-          -#}
-          {% with docstring_sections = function.docstring.parsed %}
-            {% include "docstring"|get_template with context %}
-          {% endwith %}
-        {% endblock docstring %}
-
-        {% block source scoped %}
-          {#- Source block.
-
-          This block renders the source code for the function.
-          -#}
-          {% if config.show_source and function.source %}
-            <details class="quote">
-              <summary>{{ lang.t("Source code in") }} <code>
-                {%- if function.relative_filepath.is_absolute() -%}
-                  {{ function.relative_package_filepath }}
-                {%- else -%}
-                  {{ function.relative_filepath }}
-                {%- endif -%}
-              </code></summary>
-              {{ function.source|highlight(language="python", linestart=function.lineno, linenums=True) }}
-            </details>
-          {% endif %}
-        {% endblock source %}
-      {% endblock contents %}
-    </div>
-
-  {% endwith %}
-</div>

pixeltable/tool/embed_udf.py

@@ -1,9 +0,0 @@
-import numpy as np
-
-import pixeltable as pxt
-
-
-# TODO This can go away once we have the ability to inline expr_udf's
-@pxt.expr_udf
-def clip_text_embed(txt: str) -> np.ndarray:
-    return pxt.functions.huggingface.clip_text(txt, model_id='openai/clip-vit-base-patch32')  # type: ignore[return-value]

pixeltable/tool/mypy_plugin.py

@@ -1,55 +0,0 @@
-from typing import Callable, Optional
-
-from mypy import nodes
-from mypy.plugin import AnalyzeTypeContext, ClassDefContext, Plugin
-from mypy.plugins.common import add_method_to_class
-from mypy.types import AnyType, Type, TypeOfAny
-
-import pixeltable as pxt
-
-
-class PxtPlugin(Plugin):
-    __UDA_FULLNAME = f'{pxt.uda.__module__}.{pxt.uda.__name__}'
-    __TYPE_MAP = {
-        pxt.Json: 'typing.Any',
-        pxt.Array: 'numpy.ndarray',
-        pxt.Image: 'PIL.Image.Image',
-        pxt.Video: 'builtins.str',
-        pxt.Audio: 'builtins.str',
-        pxt.Document: 'builtins.str',
-    }
-    __FULLNAME_MAP = {
-        f'{k.__module__}.{k.__name__}': v
-        for k, v in __TYPE_MAP.items()
-    }
-
-    def get_type_analyze_hook(self, fullname: str) -> Optional[Callable[[AnalyzeTypeContext], Type]]:
-        if fullname in self.__FULLNAME_MAP:
-            subst_name = self.__FULLNAME_MAP[fullname]
-            return lambda ctx: pxt_hook(ctx, subst_name)
-        return None
-
-    def get_class_decorator_hook_2(self, fullname: str) -> Optional[Callable[[ClassDefContext], bool]]:
-        if fullname == self.__UDA_FULLNAME:
-            return pxt_decorator_hook
-        return None
-
-def plugin(version: str) -> type:
-    return PxtPlugin
-
-def pxt_hook(ctx: AnalyzeTypeContext, subst_name: str) -> Type:
-    if subst_name == 'typing.Any':
-        return AnyType(TypeOfAny.special_form)
-    return ctx.api.named_type(subst_name, [])
-
-def pxt_decorator_hook(ctx: ClassDefContext) -> bool:
-    arg = nodes.Argument(nodes.Var('fn'), AnyType(TypeOfAny.special_form), None, nodes.ARG_POS)
-    add_method_to_class(
-        ctx.api,
-        ctx.cls,
-        "to_sql",
-        args=[arg],
-        return_type=AnyType(TypeOfAny.special_form),
-        is_staticmethod=True,
-    )
-    return True

pixeltable-0.2.28.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[mkdocstrings.python.templates]
-extension-name=pixeltable.tool.doc_plugins.mkdocstrings:get_templates_path
-