python_code stringlengths 0 4.04M | repo_name stringlengths 7 58 | file_path stringlengths 5 147 |
|---|---|---|
"""Misc utils."""
import logging
from pathlib import Path
from typing import List
from rich.logging import RichHandler
def setup_logger(log_dir: str):
"""Create log directory and logger."""
Path(log_dir).mkdir(exist_ok=True, parents=True)
log_path = str(Path(log_dir) / "log.txt")
handlers = [logging.... | fm_data_tasks-main | fm_data_tasks/utils/utils.py |
"""Prompt utils."""
import logging
from typing import Any, Tuple
import numpy as np
import pandas as pd
from sentence_transformers import SentenceTransformer
from fm_data_tasks.utils import constants
from fm_data_tasks.utils.data_utils import sample_train_data
logger = logging.getLogger(__name__)
def get_manual_pr... | fm_data_tasks-main | fm_data_tasks/utils/prompt_utils.py |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import io
import os
# Note: To use the 'upload' functionality of this file, you must:
# $ pipenv install twine --dev
import shutil
import subprocess
import sys
from distutils.util import convert_path
from shutil import rmtree
from setuptools import Command, find_packag... | meerkat-main | setup.py |
"""Multiple galleries in tabs, with independent sorting."""
import meerkat as mk
df1 = mk.get("imagenette", version="160px")
df2 = mk.get("imagenette", version="160px")
sort1 = mk.gui.Sort(df1, title="Sort (Dataframe 1)")
sort2 = mk.gui.Sort(df2, title="Sort (Dataframe 2)")
galleries = mk.gui.Tabs(
tabs={
... | meerkat-main | demo/multiple-sort.py |
"""A head-to-head reader study.
The reader inspects all variants of an image and selects the best one.
"""
import numpy as np
from PIL import Image
import meerkat as mk
from meerkat.interactive import html
def add_noise(img: Image) -> Image:
"""Simulate a noisy image."""
img = np.asarray(img).copy()
img... | meerkat-main | demo/reader-study.py |
"""Display a data frame in an interactive table and gallery in a tabbed
view."""
import meerkat as mk
# Load in the imagenette dataset
df = mk.get("imagenette", version="160px")
# Create a Table and Gallery view of the data
table = mk.gui.Table(df)
gallery = mk.gui.Gallery(df, main_column="img")
# Put the two views ... | meerkat-main | demo/tabbed-views.py |
"""Display images in an interactive gallery.
This is a tutorial on how to build a basic interactive application with
Meerkat.
"""
import meerkat as mk
df = mk.get("imagenette", version="160px")
gallery = mk.gui.Gallery(df, main_column="img", tag_columns=["path", "label"])
page = mk.gui.Page(gallery, id="gallery")
pa... | meerkat-main | demo/tutorial-image-gallery.py |
"""Sort an image dataset in a gallery."""
import meerkat as mk
df = mk.get("imagenette", version="160px")
df = df.mark()
sort = mk.gui.Sort(df)
# Show the sorted DataFrame in a gallery.
gallery = mk.gui.Gallery(sort(df), main_column="img")
page = mk.gui.Page(
mk.gui.html.div([sort, gallery], classes="flex flex-... | meerkat-main | demo/sort.py |
from PIL import Image
import meerkat as mk
# Load the dataset
df = mk.get(
"poloclub/diffusiondb",
version="large_random_1k",
registry="huggingface",
)["train"]
for col in df.columns:
df[col] = df[col].to_numpy()
df["image_path"] = df["image"].defer(lambda x: x["path"])
df["image"] = (
df["image_... | meerkat-main | demo/diffusiondb.py |
from datetime import datetime
from typing import List
import meerkat as mk
from meerkat.interactive import html
from meerkat.interactive.app.src.lib.component.core.filter import FilterCriterion
# Data loading.
imagenette = mk.get("imagenette", version="160px")
imagenette = imagenette[["img_id", "path", "img", "label"... | meerkat-main | demo/error-analysis.py |
import meerkat as mk
@mk.reactive()
def square(a: float) -> float:
return a**2
@mk.reactive()
def multiply(coef: float, a: float) -> float:
return coef * a
@mk.endpoint()
def increment(value: mk.Store):
value.set(value + 1)
input_slider = mk.gui.Slider(value=2.0)
coef_slider = mk.gui.Slider(value=2.... | meerkat-main | demo/quickstart-interactive.py |
"""A reactive image viewer that allows you to select a class and see 16 random
images from that class.
This is a tutorial on how to use `reactive` functions in Meerkat, to
build complex reactive workflows.
"""
import meerkat as mk
df = mk.get("imagenette", version="160px")
IMAGE_COL = "img"
LABEL_COL = "label"
@mk... | meerkat-main | demo/tutorial-reactive-viewer.py |
import os
from gpt_index import GPTSimpleVectorIndex, SimpleDirectoryReader
import meerkat as mk
from meerkat.interactive import (
Button,
Caption,
Header,
Page,
Store,
Subheader,
Textbox,
endpoint,
html,
print,
reactive,
)
# Decorate with @reactive so that this fn is rea... | meerkat-main | demo/gpt-index.py |
"""Filter and sort an image dataset in a gallery.
This is a tutorial on how to compose complex data components like
`Filter`, `Sort`, and `Gallery` in Meerkat in order to create an
application.
"""
import meerkat as mk
df = mk.get("imagenette", version="160px")
filter = mk.gui.Filter(df)
sort = mk.gui.Sort(df)
galle... | meerkat-main | demo/tutorial-filter-sort.py |
"""Similarity search with CLIP in an interactive image gallery, with advanced
controls for user feedback."""
import rich
import meerkat as mk
from meerkat.interactive.app.src.lib.component.contrib import GalleryQuery
IMAGE_COLUMN = "img"
EMBED_COLUMN = "img_clip"
rich.print(
"[bold red]This script uses CLIP to e... | meerkat-main | demo/match-2.py |
"""Build a simple chat app with Meerkat."""
# TODO: improve the chat component
from datetime import datetime
import meerkat as mk
from meerkat.interactive.app.src.lib.component.core.chat import Chat
def get_time_elapsed(time):
# datetime.now() will be different for each cell, which may cause
# inconsistencie... | meerkat-main | demo/chat.py |
import meerkat as mk
IMAGE_COLUMN = "img"
EMBED_COLUMN = "img_clip"
@mk.endpoint()
def append_to_sort(match_criterion, criteria: mk.Store):
"""Add match criterion to the sort criteria.
Args:
match_criterion: The criterion to add.
This is returned by the match component.
criteria:... | meerkat-main | demo/image-search.py |
"""Run ChatGPT with Meerkat's Chat page.
Requirements:
- Download manifest: `pip install manifest-ml[chatgpt]`
- Follow instructions to get your ChatGPT session key:
https://github.com/HazyResearch/manifest
Run:
CHATGPT_SESSION_KEY="your_session_key" python chatgpt.py
"""
import os
from datetime imp... | meerkat-main | demo/chatgpt.py |
"""Flash-fill.
Run this script with:
OPENAI_API_KEY`mk run flash-fill.py`.
Requirements:
pip install manifest-ml
"""
import os
import meerkat as mk
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
ARXIV_DATASET_JSON = os.getenv("ARXIV_DATASET_JSON")
PDF_CACHE = os.getenv("PDF_CACHE", "~/.meerkat/cache/arxiv-dat... | meerkat-main | demo/flash-fill.py |
"""Query a large language model (LLM) with a question and get an answer.
This is a tutorial on creating an `endpoint` in Meerkat that responds to
a button click.
"""
import os
from manifest import Manifest
import meerkat as mk
manifest = Manifest(
client_name="openai",
client_connection=os.getenv("OPENAI_AP... | meerkat-main | demo/tutorial-query-llm.py |
"""An assortment of Flowbite components."""
import meerkat as mk
from meerkat.interactive import flowbite as fb
from meerkat.interactive import html as html
@mk.endpoint()
def on_click():
print("Clicked!")
button = fb.Button(
slots="Click me",
on_click=on_click,
)
card = fb.Card(
slots=[
mk... | meerkat-main | demo/flowbite.py |
"""Filter an image dataset in a gallery."""
import meerkat as mk
df = mk.get("imagenette", version="160px")
filter = mk.gui.Filter(df)
df = filter(df)
gallery = mk.gui.Gallery(df, main_column="img")
page = mk.gui.Page(
mk.gui.html.flexcol([filter, gallery]),
id="filter",
)
page.launch()
| meerkat-main | demo/filter.py |
"""Display a data frame in an interactive table."""
import meerkat as mk
df = mk.get("imagenette", version="160px")
table = mk.gui.Table(df)
page = mk.gui.Page(table, id="table")
page.launch()
| meerkat-main | demo/table.py |
"""Flash-fill."""
import os
from functools import partial
from manifest import Manifest
import meerkat as mk
from meerkat.dataframe import Batch
manifest = Manifest(
client_name="openai",
client_connection=os.getenv("OPENAI_API_KEY"),
)
def complete_prompt(row, example_template: mk.Store[str]):
assert ... | meerkat-main | demo/prompt.py |
"""A demo for segmenting images with the Segment Anything Model (SAM).
This demo requires access to the Segment Anything Model (SAM) model.
https://github.com/facebookresearch/segment-anything
"""
# flake8: noqa: E402
import os
from typing import List
os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
import matplotli... | meerkat-main | demo/sam.py |
import meerkat as mk
from meerkat.interactive.formatter.raw_html import HTMLFormatterGroup
df = mk.get("olivierdehaene/xkcd", registry="huggingface")["train"]
for col in df.columns:
df[col] = df[col].to_numpy()
df["webpage"] = mk.files(df["url"]).format(HTMLFormatterGroup().defer())
filter = mk.gui.Filter(df)
f... | meerkat-main | demo/xkcd.py |
"""Similarity search with CLIP in an interactive image gallery."""
import rich
import meerkat as mk
IMAGE_COLUMN = "img"
EMBED_COLUMN = "img_clip"
rich.print(
"[bold red]This script uses CLIP to embed images. "
"This will take some time to download the model. "
"Please be patient.[/bold red]"
)
df = mk.... | meerkat-main | demo/match.py |
meerkat-main | demo/together/__init__.py | |
meerkat-main | demo/together/main_together.py | |
"""A basic chatbot implementation that uses Meerkat to create a chatbot and
manage its state, and MiniChain to perform prompting.
Borrows code from [MiniChain](https://github.com/srush/minichain)'s
chatbot example.
"""
import json
import os
import pathlib
from dataclasses import dataclass
from datetime import datetime... | meerkat-main | demo/chatbot/chatbot_basic_minichain.py |
import json
import os
import shutil
from datetime import datetime
import openai
import meerkat as mk
from demo.chatbot.characters import CHARACTERS
CHATBOT = "chatbot"
USER = "user"
class ConversationHistory:
"""Stores the full conversation history, and keeps track of the agent's
memory to use for promptin... | meerkat-main | demo/chatbot/chatbot_chatgpt_character.py |
"""A ChatGPT demo, built in Meerkat."""
import os
import meerkat as mk
from demo.chatbot.chatbot_chatgpt import ChatGPT
FILEPATH = os.path.dirname(os.path.abspath(__file__))
chatgpt = ChatGPT(savepath=os.path.join(FILEPATH, "history.chatgpt.jsonl"))
page = mk.gui.Page(chatgpt, id="chatgpt")
page.launch()
| meerkat-main | demo/chatbot/main_chatgpt.py |
"""A lofi version of character.ai, built in Meerkat with ChatGPT."""
import os
import meerkat as mk
from demo.chatbot.chatbot_chatgpt_character import CharacterChatbot
FILEPATH = os.path.dirname(os.path.abspath(__file__))
charbot = CharacterChatbot(
savepath=os.path.join(FILEPATH, "history.charbot.jsonl"),
)
pag... | meerkat-main | demo/chatbot/main_chatgpt_character.py |
# flake8: noqa
CHARACTERS = [
{
"id": "galileo",
"character": "Galileo Galilei",
"instructions": "You are Galileo Galilei, an Italian astronomer, physicist, and mathematician who played a major role in the Scientific Revolution. You made significant contributions to the fields of astronomy, ... | meerkat-main | demo/chatbot/characters.py |
import json
import os
import shutil
from datetime import datetime
import openai
import meerkat as mk
CHATBOT = "chatbot"
USER = "user"
class ConversationHistory:
"""Stores the full conversation history, and keeps track of the agent's
memory to use for prompting."""
def __init__(
self,
... | meerkat-main | demo/chatbot/chatbot_chatgpt.py |
"""A basic chatbot demo, powered by Meerkat and Minichain."""
import os
import meerkat as mk
from demo.chatbot.chatbot_basic_minichain import BasicChatbot
FILEPATH = os.path.dirname(os.path.abspath(__file__))
chatbot = BasicChatbot(
model="text-davinci-003",
chatbot_name="🤖 Meerkat",
user_name="Me",
... | meerkat-main | demo/chatbot/main_basic_minichain.py |
from __future__ import annotations
import os
from dataclasses import dataclass
from pathlib import Path
import yaml
CONFIG_ENV_VARIABLE = "MEERKAT_CONFIG"
DATASETS_ENV_VARIABLE = "MEERKAT_DATASETS"
@dataclass
class MeerkatConfig:
display: DisplayConfig
datasets: DatasetsConfig
system: SystemConfig
... | meerkat-main | meerkat/config.py |
__version__ = "0.4.11"
| meerkat-main | meerkat/version.py |
"""Adapted from
https://github.com/ad12/meddlr/blob/main/meddlr/utils/env.py."""
import importlib
import re
from importlib import util
from packaging import version
_SUPPORTED_PACKAGES = {}
def package_available(name: str) -> bool:
"""Returns if package is available.
Args:
name (str): Name of the p... | meerkat-main | meerkat/env.py |
from functools import lru_cache
import numpy as np
import pandas as pd
from meerkat.columns.abstract import Column
from meerkat.columns.scalar.abstract import ScalarColumn
from meerkat.interactive.node import NodeMixin
from meerkat.mixins.identifiable import IdentifiableMixin
from meerkat.provenance import Provenance... | meerkat-main | meerkat/ibis.py |
from .dataframe import DataFrame
# TODO: remove this once we're satisfying re-backwards compatibility
DataPanel = DataFrame
__all__ = ["DataPanel"]
| meerkat-main | meerkat/datapanel.py |
"""DataFrame class."""
from __future__ import annotations
import logging
import os
import pathlib
import shutil
import warnings
from typing import (
TYPE_CHECKING,
Any,
Callable,
Collection,
Dict,
Iterable,
List,
Mapping,
Optional,
Sequence,
Set,
Tuple,
Type,
Uni... | meerkat-main | meerkat/dataframe.py |
import json
import logging
import os
import re
import shutil
import subprocess
import sys
import uuid
from enum import Enum
from typing import TYPE_CHECKING, List, Optional
import rich
from jinja2 import Environment, FileSystemLoader
from tabulate import tabulate
from meerkat.tools.singleton import Singleton
if TYPE... | meerkat-main | meerkat/constants.py |
"""Meerkat."""
# flake8: noqa
from json import JSONEncoder
def _default(self, obj):
# https://stackoverflow.com/a/18561055
# Monkey patch json module at import time so
# JSONEncoder.default() checks for a "to_json()"
# method and uses it to encode objects if it exists
# Note: this may not have be... | meerkat-main | meerkat/__init__.py |
from __future__ import annotations
import base64
from io import BytesIO
from typing import TYPE_CHECKING, Any
from PIL import Image
import meerkat as mk
if TYPE_CHECKING:
from meerkat.columns.deferred.base import DeferredCell
from meerkat.columns.deferred.file import FileCell
def auto_formatter(cell: Any)... | meerkat-main | meerkat/display.py |
class MergeError(ValueError):
pass
class ConcatError(ValueError):
pass
class ConcatWarning(RuntimeWarning):
pass
class ConsolidationError(ValueError):
pass
class ImmutableError(ValueError):
pass
class ConversionError(ValueError):
pass
class ExperimentalWarning(FutureWarning):
pas... | meerkat-main | meerkat/errors.py |
from __future__ import annotations
import warnings
import weakref
from copy import copy
from functools import wraps
from inspect import getcallargs
from typing import Any, Dict, List, Mapping, Sequence, Tuple, Union
import meerkat as mk
from meerkat.errors import ExperimentalWarning
_provenance_enabled = False
def... | meerkat-main | meerkat/provenance.py |
from meerkat.columns.deferred.base import DeferredCell
class Row(dict):
def __call__(self):
# FIXME(Sabri): Need to actually implement this based on the DAG of the deferred
# cells for effiency.
return Row(
{
name: cell() if isinstance(cell, DeferredCell) else c... | meerkat-main | meerkat/row.py |
import logging
import os
import subprocess
import time
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional
from fastapi import FastAPI, HTTPException
from meerkat.interactive.server import Server
from meerkat.tools.utils import WeakMapping
if TYPE_CHECKING:
... | meerkat-main | meerkat/state.py |
from __future__ import annotations
import abc
class AbstractCell(abc.ABC):
def __init__(self, *args, **kwargs):
super(AbstractCell, self).__init__(*args, **kwargs)
def get(self, *args, **kwargs) -> object:
"""Get me the thing that this cell exists for."""
raise NotImplementedError("M... | meerkat-main | meerkat/cells/abstract.py |
meerkat-main | meerkat/cells/__init__.py | |
from __future__ import annotations
from pathlib import Path
from typing import Callable, Dict, Sequence, Union
from meerkat.cells.abstract import AbstractCell
from meerkat.mixins.cloneable import StateClass
from meerkat.mixins.file import PathLikeType, PathsMixin
from meerkat.tools.lazy_loader import LazyLoader
pydi... | meerkat-main | meerkat/cells/volume.py |
from meerkat import env
from meerkat.tools.lazy_loader import LazyLoader
from meerkat.tools.utils import requires
torch = LazyLoader("torch")
torchaudio = LazyLoader("torchaudio")
class Audio:
def __init__(
self,
data,
sampling_rate: int,
bits: int = None,
) -> None:
i... | meerkat-main | meerkat/cells/audio.py |
from __future__ import annotations
from meerkat.cells.abstract import AbstractCell
from meerkat.tools.lazy_loader import LazyLoader
spacy = LazyLoader("spacy")
spacy_attrs = LazyLoader("spacy.attrs")
spacy_tokens = LazyLoader("spacy.tokens")
class SpacyCell(AbstractCell):
def __init__(
self,
doc... | meerkat-main | meerkat/cells/spacy.py |
# coding=utf-8
# Copyright 2020 The TF-Agents Authors.
#
# 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable la... | meerkat-main | meerkat/tools/lazy_loader.py |
import functools
from typing import Any, List, Optional, Sequence
from fvcore.common.registry import Registry as _Registry
from tabulate import tabulate
from meerkat.dataframe import DataFrame
class Registry(_Registry):
"""Extension of fvcore's registry that supports aliases."""
_ALIAS_KEYWORDS = ("_aliase... | meerkat-main | meerkat/tools/registry.py |
"""Adapted from https://github.com/facebookresearch/detectron2."""
import importlib
import os
import platform
import re
import subprocess
import sys
from collections import defaultdict
import numpy as np
import PIL
from tabulate import tabulate
from meerkat.tools.lazy_loader import LazyLoader
from meerkat.version imp... | meerkat-main | meerkat/tools/collect_env.py |
meerkat-main | meerkat/tools/__init__.py | |
import abc
from string import Template
from textwrap import dedent, indent
from typing import Any, Callable, Dict
FuncType = Callable[..., Any]
GLOBAL_DOCS = {}
def doc(source: Dict[str, str] = None, **kwargs) -> Callable[[FuncType], FuncType]:
"""
A decorator take docstring templates, concatenate them and ... | meerkat-main | meerkat/tools/docs.py |
"""
Source: https://github.com/dmfrey/FileLock
"""
import errno
import os
import time
class FileLockException(Exception):
pass
class FileLock(object):
"""A file locking mechanism that has context-manager support so you can use
it in a with statement.
This should be relatively cross compatible as i... | meerkat-main | meerkat/tools/filelock.py |
import inspect
import sys
import types
import typing
import warnings
import weakref
from collections import defaultdict
from collections.abc import Mapping
from functools import reduce, wraps
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
import dill
import numpy as np
import pandas as pd
impo... | meerkat-main | meerkat/tools/utils.py |
class Singleton(type):
"""A metaclass that ensures only one instance of a class is created.
Usage:
>>> class Example(metaclass=Singleton):
... def __init__(self, x):
... self.x = x
>>> a = Example(1)
>>> b = Example(2)
>>> print(a, id(a))
<__... | meerkat-main | meerkat/tools/singleton.py |
import abc
class AbstractWriter(abc.ABC):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def __repr__(self):
return f"{self.__class__.__name__}"
def __str__(self):
return f"{self.__class__.__name__}"
@abc.abstractmethod
def open(self, *args, **kwa... | meerkat-main | meerkat/writers/abstract.py |
from meerkat.columns.abstract import Column
from meerkat.writers.abstract import AbstractWriter
class ConcatWriter(AbstractWriter):
def __init__(
self,
output_type: type = Column,
template: Column = None,
*args,
**kwargs,
):
super(ConcatWriter, self).__init__(*a... | meerkat-main | meerkat/writers/concat_writer.py |
meerkat-main | meerkat/writers/__init__.py | |
import os
from pathlib import Path
from numpy.lib.format import open_memmap
from meerkat.columns.abstract import Column
from meerkat.columns.tensor.numpy import NumPyTensorColumn
from meerkat.writers.abstract import AbstractWriter
class NumpyMemmapWriter(AbstractWriter):
def __init__(
self,
path... | meerkat-main | meerkat/writers/numpy_writer.py |
from typing import Callable, Union
class AggregationError(ValueError):
pass
class AggregateMixin:
AGGREGATIONS = [
"mean",
]
def __init__(self, *args, **kwargs):
super().__init__()
def aggregate(self, function: Union[Callable, str], *args, **kwargs):
if isinstance(funct... | meerkat-main | meerkat/mixins/aggregate.py |
from collections.abc import Callable
from typing import List
def identity_collate(batch: List):
return batch
class CollateMixin:
def __init__(self, collate_fn: Callable = None, *args, **kwargs):
super(CollateMixin, self).__init__(*args, **kwargs)
if collate_fn is not None:
self.... | meerkat-main | meerkat/mixins/collate.py |
from collections.abc import Callable, Mapping, Sequence
from types import SimpleNamespace
import numpy as np
from meerkat.tools.lazy_loader import LazyLoader
torch = LazyLoader("torch")
class FunctionInspectorMixin:
def __init__(self, *args, **kwargs):
super(FunctionInspectorMixin, self).__init__(*args... | meerkat-main | meerkat/mixins/inspect_fn.py |
import os
import dill
from meerkat.tools.utils import dump_yaml, load_yaml, meerkat_dill_load
class ColumnIOMixin:
def write(self, path: str, *args, **kwargs) -> None:
assert hasattr(self, "_data"), f"{self.__class__.__name__} requires `self.data`"
# Make all the directories to the path
... | meerkat-main | meerkat/mixins/io.py |
import logging
from typing import TYPE_CHECKING, Callable, Mapping, Sequence, Type, Union
from pandas.util._decorators import doc
from meerkat.ops.map import defer
if TYPE_CHECKING:
from meerkat.columns.abstract import Column
from meerkat.columns.deferred.base import DeferredColumn
from meerkat.dataframe... | meerkat-main | meerkat/mixins/deferable.py |
import inspect
import warnings
from typing import Any
from meerkat.interactive.graph.marking import (
is_unmarked_context,
is_unmarked_fn,
unmarked,
)
class MarkableMixin:
"""A class that can be marked."""
_self_marked: bool = False
@property
def marked(self):
return self._self_... | meerkat-main | meerkat/mixins/reactifiable.py |
meerkat-main | meerkat/mixins/__init__.py | |
import os
from pathlib import Path
from typing import Sequence, Union
PathLikeType = Union[str, Path, os.PathLike]
PathLike = (str, Path, os.PathLike)
class FileMixin:
"""Mixin for adding in single filepath."""
# TODO(karan): this also actually works on dirs, so rename
def __init__(self, filepath: Unio... | meerkat-main | meerkat/mixins/file.py |
from meerkat.block.abstract import BlockView
class BlockableMixin:
def __init__(self, *args, **kwargs):
super(BlockableMixin, self).__init__(*args, **kwargs)
block_class: type = None
@classmethod
def is_blockable(cls):
return cls.block_class is not None
def _unpack_block_view(se... | meerkat-main | meerkat/mixins/blockable.py |
from uuid import uuid4
from meerkat.tools.utils import classproperty
_MK_ID_PREFIX = "__mkid__"
class IdentifiableMixin:
"""Mixin for classes, to give objects an id.
This class must use _self_{attribute} for all attributes since it
will be mixed into the wrapt.ObjectProxy class, which requires this
... | meerkat-main | meerkat/mixins/identifiable.py |
from pyparsing import Mapping
class MaterializationMixin:
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
@property
def mz(self):
return _MaterializeIndexer(self)
class _MaterializeIndexer:
def __init__(self, obj: object):
self.obj = obj
def __get... | meerkat-main | meerkat/mixins/indexing.py |
import logging
from typing import Callable, Dict, Mapping, Optional, Union
import numpy as np
from tqdm.auto import tqdm
from meerkat.provenance import capture_provenance
logger = logging.getLogger(__name__)
class MappableMixin:
def __init__(self, *args, **kwargs):
super(MappableMixin, self).__init__(*... | meerkat-main | meerkat/mixins/mapping.py |
from dataclasses import dataclass
from meerkat.interactive.node import NodeMixin
from meerkat.mixins.blockable import BlockableMixin
from meerkat.mixins.identifiable import IdentifiableMixin
from meerkat.provenance import ProvenanceMixin
@dataclass
class StateClass:
"""An internal class to store the state of an ... | meerkat-main | meerkat/mixins/cloneable.py |
import json
import os
from abc import ABC, abstractmethod
from typing import List
import meerkat as mk
from ..config import DATASETS_ENV_VARIABLE
from .info import DatasetInfo
from .utils import download_url
class DatasetBuilder(ABC):
REVISIONS: List[str]
info: DatasetInfo = None
def __init__(
... | meerkat-main | meerkat/datasets/abstract.py |
import functools
from typing import Any, List, Optional, Sequence
from fvcore.common.registry import Registry as _Registry
from tabulate import tabulate
from meerkat.dataframe import DataFrame
class Registry(_Registry):
"""Extension of fvcore's registry that supports aliases."""
_ALIAS_KEYWORDS = ("_aliase... | meerkat-main | meerkat/datasets/registry.py |
from typing import Dict, List, Union
from meerkat.dataframe import DataFrame
from .celeba import celeba
from .coco import coco
from .expw import expw
from .fer import fer
from .gtsdb import gtsdb
from .imagenet import imagenet
from .imagenette import imagenette
from .lra import pathfinder
from .lvis import lvis
from ... | meerkat-main | meerkat/datasets/__init__.py |
import os
import shutil
import tarfile
from meerkat import env
from meerkat.dataframe import DataFrame
from meerkat.tools.utils import requires
_IS_HF_AVAILABLE = env.package_available("huggingface_hub")
if _IS_HF_AVAILABLE:
import huggingface_hub
def download_url(url: str, dataset_dir: str, force: bool = False... | meerkat-main | meerkat/datasets/utils.py |
from dataclasses import dataclass
@dataclass
class DatasetInfo:
name: str
full_name: str = None
description: str = None
citation: str = None
homepage: str = None
license: str = None
tags: str = None
| meerkat-main | meerkat/datasets/info.py |
from __future__ import annotations
import hashlib
import json
import os
from dataclasses import dataclass
import numpy as np
import meerkat as mk
from ..abstract import DatasetBuilder
from ..info import DatasetInfo
from ..registry import datasets
from ..utils import download_url, extract
IMAGE_URL = "http://images... | meerkat-main | meerkat/datasets/lvis/__init__.py |
import os
import shutil
import meerkat as mk
from ..abstract import DatasetBuilder
from ..info import DatasetInfo
from ..registry import datasets
from ..utils import download_url, extract
@datasets.register()
class pascal(DatasetBuilder):
VERSIONS = ["2012"]
VERSION_TO_URL = {
# flake8: noqa
... | meerkat-main | meerkat/datasets/pascal/__init__.py |
"""Datasets for Long Range Arena (LRA) Pathfinder task."""
import itertools
import os
import pandas as pd
import meerkat as mk
from meerkat.tools.lazy_loader import LazyLoader
from ..abstract import DatasetBuilder
from ..info import DatasetInfo
from ..registry import datasets
from ..utils import download_url
tf = L... | meerkat-main | meerkat/datasets/lra/pathfinder.py |
from .pathfinder import pathfinder
__all__ = ["pathfinder"]
| meerkat-main | meerkat/datasets/lra/__init__.py |
import os
import subprocess
import PIL
import meerkat as mk
from meerkat.columns.deferred.image import load_image
from ..abstract import DatasetBuilder
from ..info import DatasetInfo
from ..registry import datasets
def _write_empty_image(dst):
img = PIL.Image.new("RGB", (32, 32), color="black")
img.save(ds... | meerkat-main | meerkat/datasets/mimic_iii/__init__.py |
import os
import subprocess
import PIL
import meerkat as mk
from meerkat.columns.deferred.image import load_image
from ..abstract import DatasetBuilder
from ..info import DatasetInfo
from ..registry import datasets
REPO = "https://github.com/NationalGalleryOfArt/opendata.git"
def _write_empty_image(dst):
img ... | meerkat-main | meerkat/datasets/ngoa/__init__.py |
# Swedish Traffic Signs Dataset (STSD)
import os
import pandas as pd
from tqdm.auto import tqdm
import meerkat as mk
from ..abstract import DatasetBuilder
from ..info import DatasetInfo
from ..registry import datasets
from ..utils import download_url, extract
_SETS_TO_URLS = {
"Set1/annotations.txt": "http://w... | meerkat-main | meerkat/datasets/stsd/__init__.py |
import os
from typing import Dict, Mapping
import ujson as json
import meerkat as mk
# TODO (Sabri): Add support for downloading the data.
# For the time being, relevant files should be downloaded to the directory here
# https://visualgenome.org/VGViz/explore
def build_visual_genome_dfs(
dataset_dir: str, writ... | meerkat-main | meerkat/datasets/visual_genome/__init__.py |
import os
import pandas as pd
from wilds import get_dataset
from wilds.datasets.wilds_dataset import WILDSDataset
import meerkat as mk
# flake8: noqa
URL = "http://worksheets.codalab.org/rest/bundles/0x505056d5cdea4e4eaa0e242cbfe2daa4/contents/blob/"
def build_waterbirds_df(
dataset_dir: str,
download: boo... | meerkat-main | meerkat/datasets/waterbirds/__init__.py |
import random
from PIL import Image
import meerkat as mk
def get_torchvision_dataset(dataset_name, download_dir, is_train):
return NotImplemented
# dataset = torchvision.datasets.__dict__[dataset_name.upper()](
# root=download_dir,
# train=is_train,
# download=True,
# )
def get... | meerkat-main | meerkat/datasets/torchvision/__init__.py |
import os
import tarfile
import pandas as pd
import meerkat as mk
from ..abstract import DatasetBuilder
from ..info import DatasetInfo
from ..registry import datasets
from ..utils import download_url, extract
ID_TO_WORDS = {
"n02979186": "cassette player",
"n03417042": "garbage truck",
"n01440764": "ten... | meerkat-main | meerkat/datasets/imagenette/__init__.py |
from meerkat.tools.lazy_loader import LazyLoader
torch = LazyLoader("torch")
transforms = LazyLoader("torchvision.transforms")
transformers = LazyLoader("transformers")
def initialize_transform(transform_name, config, dataset):
if transform_name is None:
return None
elif transform_name == "bert":
... | meerkat-main | meerkat/datasets/wilds/transforms.py |
"""WILDS configuration defaults and operations.
All default configurations are integrated from the WILDS repository: htt
ps://github.com/p-lambda/wilds/blob/ca7e4fd345aa4f998b8322191b083444d85e
2a08/examples/configs/datasets.py
"""
base_config = {
"split_scheme": None,
"dataset_kwargs": {},
"download": Fa... | meerkat-main | meerkat/datasets/wilds/config.py |
"""WILDS integration for Meerkat."""
from __future__ import annotations
from argparse import Namespace
from typing import TYPE_CHECKING, List
import numpy as np
import pandas as pd
from meerkat.columns.abstract import Column
from meerkat.columns.tensor.numpy import NumPyTensorColumn
from meerkat.dataframe import Dat... | meerkat-main | meerkat/datasets/wilds/__init__.py |
import json
import os
from typing import List
import pandas as pd
import meerkat as mk
IMAGES_URLS = {
"train": "https://ml-inat-competition-datasets.s3.amazonaws.com/2021/train.tar.gz",
"val": "https://ml-inat-competition-datasets.s3.amazonaws.com/2021/val.tar.gz",
"test": "https://ml-inat-competition-d... | meerkat-main | meerkat/datasets/inaturalist/__init__.py |
import json
import os
from typing import Dict, List, Union
import meerkat as mk
def build_audioset_df(
dataset_dir: str,
splits: List[str] = None,
audio_column: bool = True,
overwrite: bool = False,
) -> Dict[str, mk.DataFrame]:
"""Build DataFrames for the audioset dataset downloaded to ``dataset... | meerkat-main | meerkat/datasets/audioset/__init__.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.