pixeltable 0.2.26__py3-none-any.whl → 0.5.7__py3-none-any.whl

pixeltable/tool/create_test_db_dump.py

@@ -1,311 +0,0 @@
-import datetime
-import json
-import logging
-import os
-import pathlib
-import subprocess
-import sys
-from typing import Any
-from zoneinfo import ZoneInfo
-
-import pixeltable_pgserver
-import toml
-
-import pixeltable as pxt
-import pixeltable.metadata as metadata
-from pixeltable.env import Env
-from pixeltable.func import Batch
-from pixeltable.io.external_store import Project
-from pixeltable.tool import embed_udf
-from pixeltable.type_system import BoolType, FloatType, ImageType, IntType, JsonType, StringType, TimestampType
-
-_logger = logging.getLogger('pixeltable')
-
-
-class Dumper:
-
-    def __init__(self, output_dir='target', db_name='pxtdump') -> None:
-        if sys.version_info >= (3, 10):
-            raise RuntimeError(
-                'This script must be run on Python 3.9. '
-                'DB dumps are incompatible across versions due to issues with pickling anonymous UDFs.'
-            )
-
-        self.output_dir = pathlib.Path(output_dir)
-        shared_home = pathlib.Path(os.environ.get('PIXELTABLE_HOME', '~/.pixeltable')).expanduser()
-        mock_home_dir = self.output_dir / '.pixeltable'
-        mock_home_dir.mkdir(parents=True, exist_ok=True)
-        os.environ['PIXELTABLE_HOME'] = str(mock_home_dir)
-        os.environ['PIXELTABLE_CONFIG'] = str(shared_home / 'config.toml')
-        os.environ['PIXELTABLE_DB'] = db_name
-        os.environ['PIXELTABLE_PGDATA'] = str(shared_home / 'pgdata')
-
-        Env._init_env(reinit_db=True)
-
-        Env.get().configure_logging(level=logging.DEBUG, to_stdout=True)
-
-    def dump_db(self) -> None:
-        md_version = metadata.VERSION
-        dump_file = self.output_dir / f'pixeltable-v{md_version:03d}-test.dump.gz'
-        _logger.info(f'Creating database dump at: {dump_file}')
-        pg_package_dir = os.path.dirname(pixeltable_pgserver.__file__)
-        pg_dump_binary = f'{pg_package_dir}/pginstall/bin/pg_dump'
-        _logger.info(f'Using pg_dump binary at: {pg_dump_binary}')
-        # We need the raw DB URL, without a driver qualifier.  (The driver qualifier is needed by
-        # SQLAlchemy, but command-line Postgres won't know how to interpret it.)
-        db_url = Env.get()._db_server.get_uri(Env.get()._db_name)
-        with open(dump_file, 'wb') as dump:
-            pg_dump_process = subprocess.Popen(
-                (pg_dump_binary, db_url, '-U', 'postgres', '-Fc'),
-                stdout=subprocess.PIPE
-            )
-            subprocess.run(
-                ('gzip', '-9'),
-                stdin=pg_dump_process.stdout,
-                stdout=dump,
-                check=True
-            )
-            if pg_dump_process.poll() != 0:
-                raise RuntimeError(f'pg_dump failed with return code {pg_dump_process.returncode}')
-        info_file = self.output_dir / f'pixeltable-v{md_version:03d}-test-info.toml'
-        git_sha = subprocess.check_output(('git', 'rev-parse', 'HEAD')).decode('ascii').strip()
-        user = os.environ.get('USER', os.environ.get('USERNAME'))
-        info_dict = {'pixeltable-dump': {
-            'metadata-version': md_version,
-            'git-sha': git_sha,
-            'datetime': datetime.datetime.now(tz=datetime.timezone.utc),
-            'user': user
-        }}
-        with open(info_file, 'w') as info:
-            toml.dump(info_dict, info)
-
-    # Expression types, predicate types, embedding indices, views on views
-    def create_tables(self) -> None:
-        schema = {
-            'c1': StringType(nullable=False),
-            'c1n': StringType(nullable=True),
-            'c2': IntType(nullable=False),
-            'c3': FloatType(nullable=False),
-            'c4': BoolType(nullable=False),
-            'c5': TimestampType(nullable=False),
-            'c6': JsonType(nullable=False),
-            'c7': JsonType(nullable=False),
-            'c8': ImageType(nullable=True)
-        }
-        t = pxt.create_table('base_table', schema, primary_key='c2')
-
-        num_rows = 20
-        d1 = {
-            'f1': 'test string 1',
-            'f2': 1,
-            'f3': 1.0,
-            'f4': True,
-            'f5': [1.0, 2.0, 3.0, 4.0],
-            'f6': {
-                'f7': 'test string 2',
-                'f8': [1.0, 2.0, 3.0, 4.0],
-            },
-        }
-        d2 = [d1, d1]
-
-        c1_data = [f'test string {i}' for i in range(num_rows)]
-        c2_data = [i for i in range(num_rows)]
-        c3_data = [float(i) for i in range(num_rows)]
-        c4_data = [bool(i % 2) for i in range(num_rows)]
-        c5_data = [datetime.datetime.now()] * num_rows
-        c6_data = [
-            {
-                'f1': f'test string {i}',
-                'f2': i,
-                'f3': float(i),
-                'f4': bool(i % 2),
-                'f5': [1.0, 2.0, 3.0, 4.0],
-                'f6': {
-                    'f7': 'test string 2',
-                    'f8': [1.0, 2.0, 3.0, 4.0],
-                },
-            }
-            for i in range(num_rows)
-        ]
-        c7_data = [d2] * num_rows
-        rows = [
-            {
-                'c1': c1_data[i],
-                'c1n': c1_data[i] if i % 10 != 0 else None,
-                'c2': c2_data[i],
-                'c3': c3_data[i],
-                'c4': c4_data[i],
-                'c5': c5_data[i],
-                'c6': c6_data[i],
-                'c7': c7_data[i],
-                'c8': None
-            }
-            for i in range(num_rows)
-        ]
-
-        self.__add_expr_columns(t, 'base_table')
-        t.insert(rows)
-
-        pxt.create_dir('views')
-
-        # simple view
-        v = pxt.create_view('views.view', t.where(t.c2 < 50))
-        self.__add_expr_columns(v, 'view')
-
-        # snapshot
-        _ = pxt.create_snapshot('views.snapshot', t.where(t.c2 >= 75))
-
-        # view of views
-        vv = pxt.create_view('views.view_of_views', v.where(t.c2 >= 25))
-        self.__add_expr_columns(vv, 'view_of_views')
-
-        # empty view
-        e = pxt.create_view('views.empty_view', t.where(t.c2 == 4171780))
-        assert e.count() == 0
-        self.__add_expr_columns(e, 'empty_view', include_expensive_functions=True)
-
-        # Add external stores
-        from pixeltable.io.external_store import MockProject
-        v._link_external_store(
-            MockProject.create(
-                v,
-                'project',
-                {'int_field': pxt.IntType()},
-                {'str_field': pxt.StringType()},
-                {'view_test_udf': 'int_field', 'c1': 'str_field'}
-            )
-        )
-        # We're just trying to test metadata here, so it's ok to link a false Label Studio project.
-        # We include a computed image column in order to ensure the creation of a stored proxy.
-        from pixeltable.io.label_studio import LabelStudioProject
-        col_mapping = Project.validate_columns(
-            v, {'str_field': pxt.StringType(), 'img_field': pxt.ImageType()}, {},
-            {'view_function_call': 'str_field', 'base_table_image_rot': 'img_field'}
-        )
-        project = LabelStudioProject('ls_project_0', 4171780, media_import_method='file', col_mapping=col_mapping)
-        v._link_external_store(project)
-        # Sanity check that the stored proxy column did get created
-        assert len(project.stored_proxies) == 1
-        assert t.base_table_image_rot.col in project.stored_proxies
-
-    def __add_expr_columns(self, t: pxt.Table, col_prefix: str, include_expensive_functions=False) -> None:
-        def add_column(col_name: str, col_expr: Any, stored: bool = True) -> None:
-            t.add_column(**{f'{col_prefix}_{col_name}': col_expr}, stored=stored)
-
-        # arithmetic_expr
-        add_column('plus', t.c2 + 6)
-        add_column('minus', t.c2 - 5)
-        add_column('times', t.c3 * 1.2)
-        add_column('div', t.c3 / 1.7)
-        add_column('mod', t.c2 % 11)
-
-        # column_property_ref
-        add_column('fileurl', t.c8.fileurl)
-        add_column('localpath', t.c8.localpath)
-
-        # comparison
-        add_column('lt', t.c2 < t.c3)
-        add_column('le', t.c2 <= t.c3)
-        add_column('gt', t.c2 > t.c3)
-        add_column('ge', t.c2 >= t.c3)
-        add_column('ne', t.c2 != t.c3)
-        add_column('eq', t.c2 == t.c3)
-
-        # compound_predicate
-        add_column('and', (t.c2 >= 5) & (t.c2 < 8))
-        add_column('or', (t.c2 > 1) | t.c4)
-        add_column('not', ~(t.c2 > 20))
-
-        # function_call
-        add_column('function_call', pxt.functions.string.format('{0} {key}', t.c1, key=t.c1))  # library function
-        add_column('test_udf', test_udf_stored(t.c2))  # stored udf
-        add_column('test_udf_batched', test_udf_stored_batched(t.c1, upper=False))  # batched stored udf
-        if include_expensive_functions:
-            # batched library function
-            add_column('batched', pxt.functions.huggingface.clip_text(t.c1, model_id='openai/clip-vit-base-patch32'))
-
-        # image_member_access
-        add_column('image_mode', t.c8.mode)
-        add_column('image_rot', t.c8.rotate(180), stored=False)
-
-        # in_predicate
-        add_column('isin_1', t.c1.isin(['test string 1', 'test string 2', 'test string 3']))
-        add_column('isin_2', t.c2.isin([1, 2, 3, 4, 5]))
-        add_column('isin_3', t.c2.isin(t.c6.f5))
-
-        # inline_array, inline_list, inline_dict
-        add_column('inline_array_1', pxt.array([[1, 2, 3], [4, 5, 6]]))
-        add_column('inline_array_2', pxt.array([['a', 'b', 'c'], ['d', 'e', 'f']]))
-        add_column('inline_array_exprs', pxt.array([[t.c2, t.c2 + 1], [t.c2 + 2, t.c2]]))
-        add_column('inline_array_mixed', pxt.array([[1, t.c2], [3, t.c2]]))
-        add_column('inline_list_1', [[1, 2, 3], [4, 5, 6]])
-        add_column('inline_list_2', [['a', 'b', 'c'], ['d', 'e', 'f']])
-        add_column('inline_list_exprs', [t.c1, [t.c1n, t.c2]])
-        add_column('inline_list_mixed', [1, 'a', t.c1, [1, 'a', t.c1n], 1, 'a'])
-        add_column('inline_dict', {'int': 22, 'dict': {'key': 'val'}, 'expr': t.c1})
-
-        # is_null
-        add_column('isnull', t.c1 == None)
-
-        # json_mapper and json_path
-        add_column('json_mapper', t.c6[3])
-        add_column('json_path', t.c6.f1)
-        add_column('json_path_nested', t.c6.f6.f7)
-        add_column('json_path_star', t.c6.f5['*'])
-        add_column('json_path_idx', t.c6.f5[3])
-        add_column('json_path_slice', t.c6.f5[1:3:2])
-
-        # literal
-        add_column('str_const', 'str')
-        add_column('int_const', 5)
-        add_column('float_const', 5.0)
-        add_column('timestamp_const_1', datetime.datetime.now())
-        add_column('timestamp_const_2', datetime.datetime.now().astimezone(ZoneInfo('America/Anchorage')))
-
-        # type_cast
-        add_column('astype', t.c2.astype(FloatType()))
-
-        # .apply
-        add_column('c2_to_string', t.c2.apply(str))
-        add_column('c6_to_string', t.c6.apply(json.dumps))
-        add_column('c6_back_to_json', t[f'{col_prefix}_c6_to_string'].apply(json.loads))
-
-        t.add_embedding_index(
-            f'{col_prefix}_function_call',
-            string_embed=pxt.functions.huggingface.clip_text.using(model_id='openai/clip-vit-base-patch32')
-        )
-
-        # query()
-        @t.query
-        def q1(i: int):
-            # this breaks; TODO: why?
-            #return t.where(t.c2 < i)
-            return t.where(t.c2 < i).select(t.c1, t.c2)
-        add_column('query_output', t.queries.q1(t.c2))
-
-        @t.query
-        def q2(s: str):
-            sim = t[f'{col_prefix}_function_call'].similarity(s)
-            return t.order_by(sim, asc=False).select(t[f'{col_prefix}_function_call']).limit(5)
-        add_column('sim_output', t.queries.q2(t.c1))
-
-
-@pxt.udf(_force_stored=True)
-def test_udf_stored(n: int) -> int:
-    return n + 1
-
-
-@pxt.udf(batch_size=4, _force_stored=True)
-def test_udf_stored_batched(strings: Batch[str], *, upper: bool = True) -> Batch[str]:
-    return [string.upper() if upper else string.lower() for string in strings]
-
-
-def main() -> None:
-    _logger.info("Creating pixeltable test artifact.")
-    dumper = Dumper()
-    dumper.create_tables()
-    dumper.dump_db()
-
-
-if __name__ == "__main__":
-    main()

pixeltable/tool/create_test_video.py

@@ -1,81 +0,0 @@
-import av  # type: ignore[import-untyped]
-import PIL.Image
-import PIL.ImageDraw
-import PIL.ImageFont
-
-from pathlib import Path
-from typing import Optional
-import tempfile
-import math
-
-def create_test_video(
-    frame_count: int,
-    frame_rate: float = 1.0,
-    frame_width: int = 224,
-    aspect_ratio: str = '16:9',
-    frame_height: Optional[int] = None,
-    output_path: Optional[Path] = None,
-    font_file: str = '/Library/Fonts/Arial Unicode.ttf',
-) -> Path:
-    """
-        Creates an .mp4 video file such as the ones in /tests/data/test_videos
-        The video contains a frame number in each frame (for visual sanity check).
-
-        Args:
-            frame_count: Number of frames to create
-            frame_rate: Frame rate of the video
-            frame_width (int): Width in pixels of the video frame. Note: cost of decoding increases dramatically
-                with frame width * frame height.
-            aspect_ratio: Aspect ratio (width/height) of the video frames string of form 'width:height'
-            frame_height: Height of the video frame, if given, aspect_ratio is ignored
-            output_path: Path to save the video file
-            font_file: Path to the font file used for text.
-    """
-
-    if output_path is None:
-        output_path = Path(tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name)
-
-    parts = [int(p) for p in aspect_ratio.split(':')]
-    assert len(parts) == 2
-    aspect_ratio = parts[0] / parts[1]
-
-    if frame_height is None:
-        frame_height = math.ceil(frame_width / aspect_ratio)
-
-    frame_size = (frame_width, frame_height)
-
-    font_size = min(frame_height, frame_width) // 4
-    font = PIL.ImageFont.truetype(font=font_file, size=font_size)
-    font_fill = 0xFFFFFF  # white
-    frame_color = 0xFFFFFF - font_fill  # black
-    # Create a video container
-    container = av.open(str(output_path), mode='w')
-
-    # Add a video stream
-    stream = container.add_stream('h264', rate=frame_rate)
-    stream.width, stream.height = frame_size
-    stream.pix_fmt = 'yuv420p'
-
-    for frame_number in range(frame_count):
-        # Create an image with a number in it
-        image = PIL.Image.new('RGB', frame_size, color=frame_color)
-        draw = PIL.ImageDraw.Draw(image)
-        # Optionally, add a font here if you have one
-        text = str(frame_number)
-        _, _, text_width, text_height = draw.textbbox((0, 0), text, font=font)
-        text_position = ((frame_size[0] - text_width) // 2, (frame_size[1] - text_height) // 2)
-        draw.text(text_position, text, font=font, fill=font_fill)
-
-        # Convert the PIL image to an AVFrame
-        frame = av.VideoFrame.from_image(image)
-
-        # Encode and write the frame
-        for packet in stream.encode(frame):
-            container.mux(packet)
-
-    # Flush and close the stream
-    for packet in stream.encode():
-        container.mux(packet)
-
-    container.close()
-    return output_path

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