id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
143,689 | import logging
from pathlib import Path
from typing import Union
logger = logging.getLogger(__name__)
The provided code snippet includes necessary dependencies for implementing the `remove_empty_directories` function. Write a Python function `def remove_empty_directories(root_dir: Union[str, Path])` to solve the follo... | Recursively remove empty directories from the root directory :param root_dir: The root directory to start removing empty directories from |
143,690 | from ctypes import Union
from typing import get_origin, get_args
from pydantic import BaseModel
def create_nested_dict(pydantic_model):
if not issubclass(pydantic_model, BaseModel):
return str(pydantic_model)
model_dict = {}
for name, field in pydantic_model.__annotations__.items():
origin... | null |
143,691 | import logging
from pathlib import Path
from typing import Union
import cv2
from freemocap.utilities.get_video_paths import get_video_paths
logger = logging.getLogger(__name__)
def get_video_paths(path_to_video_folder: Union[str, Path]) -> list:
"""Search the folder for 'mp4' files (case insensitive) and return th... | Get the number of frames in the first video in a folder |
143,692 | from pathlib import Path
from typing import Union
import sass
def compile_scss_to_css(scss_path: Union[str, Path], css_path: Union[str, Path]):
with open(scss_path) as scss_file:
scss_contents = scss_file.read()
compiled_css = sass.compile(string=scss_contents)
with open(css_path, "w") as css_fil... | null |
143,693 | from pathlib import Path
from typing import Union
from PySide6.QtWidgets import QWidget
def apply_css_style_sheet(qt_widget: QWidget, path_to_css_file: Union[str, Path]):
with open(path_to_css_file, "r") as css_file:
css_string = css_file.read()
qt_widget.setStyleSheet(css_string) | null |
143,694 | from pyqtgraph.parametertree import Parameter
from skellytracker.trackers.mediapipe_tracker.mediapipe_model_info import (
MediapipeTrackingParams,
)
from freemocap.data_layer.recording_models.post_processing_parameter_models import (
ProcessingParameterModel,
AniposeTriangulate3DParametersModel,
PostPro... | null |
143,695 | from pyqtgraph.parametertree import Parameter
from skellytracker.trackers.mediapipe_tracker.mediapipe_model_info import (
MediapipeTrackingParams,
)
from freemocap.data_layer.recording_models.post_processing_parameter_models import (
ProcessingParameterModel,
AniposeTriangulate3DParametersModel,
PostPro... | null |
143,696 | from pyqtgraph.parametertree import Parameter
from skellytracker.trackers.mediapipe_tracker.mediapipe_model_info import (
MediapipeTrackingParams,
)
from freemocap.data_layer.recording_models.post_processing_parameter_models import (
ProcessingParameterModel,
AniposeTriangulate3DParametersModel,
PostPro... | null |
143,697 | from pyqtgraph.parametertree import Parameter
from skellytracker.trackers.mediapipe_tracker.mediapipe_model_info import (
MediapipeTrackingParams,
)
from freemocap.data_layer.recording_models.post_processing_parameter_models import (
ProcessingParameterModel,
AniposeTriangulate3DParametersModel,
PostPro... | null |
143,698 | import logging
import shutil
from pathlib import Path
from typing import Union
logger = logging.getLogger(__name__)
def copy_directory_if_contains_timestamps(source_dir: Union[Path, str], destination_dir: Union[Path, str]) -> bool:
source_path = Path(source_dir)
destination_path = Path(destination_dir)
# ... | null |
143,699 | import colorsys
import numpy as np
def bright_color_generator():
hue = 0 # initialize hue
while True:
# create a bright color by using the full saturation and value
# hue is varied over time to generate different colors
r, g, b = [int(255 * i) for i in colorsys.hsv_to_rgb(hue, 1, 1)]
... | null |
143,700 | import colorsys
import numpy as np
bright_colors = bright_color_generator()
def get_next_color():
return next(bright_colors) | null |
143,701 | import colorsys
import numpy as np
def rgb_color_generator(start_color, end_color, phase_increment=0.01):
r_start, g_start, b_start = start_color
r_end, g_end, b_end = end_color
# Calculate the range of each color
r_range = r_end - r_start
g_range = g_end - g_start
b_range = b_end - b_start
... | null |
143,702 | import logging
import toml
from freemocap.data_layer.recording_models.recording_info_model import RecordingInfoModel
from freemocap.system.paths_and_filenames.path_getters import get_most_recent_recording_toml_path
logger = logging.getLogger(__name__)
class RecordingInfoModel:
def __init__(
self,
r... | Save the most recent recording path to a toml file |
143,703 | import json
from pydantic import BaseModel
class GuiState(BaseModel):
send_user_pings: bool = True
show_welcome_screen: bool = True
auto_process_videos_on_save: bool = True
generate_jupyter_notebook: bool = True
auto_open_in_blender: bool = True
charuco_square_size: float = 39
annotate_charu... | null |
143,704 | import json
from pydantic import BaseModel
class GuiState(BaseModel):
send_user_pings: bool = True
show_welcome_screen: bool = True
auto_process_videos_on_save: bool = True
generate_jupyter_notebook: bool = True
auto_open_in_blender: bool = True
charuco_square_size: float = 39
annotate_charu... | null |
143,705 | import logging
import signal
import sys
from pathlib import Path
from importlib.metadata import distributions
from PySide6.QtCore import QTimer
from PySide6.QtWidgets import QApplication
from freemocap.gui.qt.main_window.freemocap_main_window import MainWindow, EXIT_CODE_REBOOT
from freemocap.gui.qt.utilities.get_qt_ap... | null |
143,706 | import nox
from nox.sessions import Session
The provided code snippet includes necessary dependencies for implementing the `coverage` function. Write a Python function `def coverage(session: Session)` to solve the following problem:
Run a coverage test on python 3.11.
Here is the function:
def coverage(session: Sess... | Run a coverage test on python 3.11. |
143,707 | import nox
from nox.sessions import Session
The provided code snippet includes necessary dependencies for implementing the `lint` function. Write a Python function `def lint(session: Session)` to solve the following problem:
Lint using Flake8
Here is the function:
def lint(session: Session):
"""Lint using Flake8... | Lint using Flake8 |
143,708 | from fastapi.middleware.cors import CORSMiddleware
def cors(app):
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
) | null |
143,709 | import logging
import traceback
from typing import Optional, Union
from fastapi import APIRouter
from jon_scratch.pupil_calibration_pipeline.qt_gl_laser_skeleton_visualizer import (
QtGlLaserSkeletonVisualizer,
)
from pydantic import BaseModel
from src.cameras.launch_camera_frame_loop import launch_camera_frame_loo... | null |
143,710 | import logging
import traceback
from typing import Optional, Union
from fastapi import APIRouter
from jon_scratch.pupil_calibration_pipeline.qt_gl_laser_skeleton_visualizer import (
QtGlLaserSkeletonVisualizer,
)
from pydantic import BaseModel
from src.cameras.launch_camera_frame_loop import launch_camera_frame_loo... | calibate capture volume - record synchronized videos (from all available camras wtih default parameters for now) and process with Anipose to produce a camera calibration (saved as a `.toml` file in the session folder |
143,711 | import logging
import traceback
from typing import Optional, Union
from fastapi import APIRouter
from jon_scratch.pupil_calibration_pipeline.qt_gl_laser_skeleton_visualizer import (
QtGlLaserSkeletonVisualizer,
)
from pydantic import BaseModel
from src.cameras.launch_camera_frame_loop import launch_camera_frame_loo... | null |
143,712 | import logging
import traceback
from typing import Optional, Union
from fastapi import APIRouter
from jon_scratch.pupil_calibration_pipeline.qt_gl_laser_skeleton_visualizer import (
QtGlLaserSkeletonVisualizer,
)
from pydantic import BaseModel
from src.cameras.launch_camera_frame_loop import launch_camera_frame_loo... | null |
143,713 | import logging
import traceback
from typing import Optional, Union
from fastapi import APIRouter
from jon_scratch.pupil_calibration_pipeline.qt_gl_laser_skeleton_visualizer import (
QtGlLaserSkeletonVisualizer,
)
from pydantic import BaseModel
from src.cameras.launch_camera_frame_loop import launch_camera_frame_loo... | null |
143,714 | import logging
import traceback
from typing import Optional, Union
from fastapi import APIRouter
from jon_scratch.pupil_calibration_pipeline.qt_gl_laser_skeleton_visualizer import (
QtGlLaserSkeletonVisualizer,
)
from pydantic import BaseModel
from src.cameras.launch_camera_frame_loop import launch_camera_frame_loo... | null |
143,715 | from fastapi import APIRouter
from pydantic import BaseModel
class HealthCheckResponse(BaseModel):
message: str = "OK"
def route():
try:
return HealthCheckResponse()
except:
raise ValueError("Unhealthy") | null |
143,716 | from fastapi import APIRouter
from src.config.data_paths import create_home_data_directory
async def handle_startup():
create_home_data_directory() | null |
143,717 | import logging
import cv2
from fastapi import APIRouter
from pydantic import BaseModel
from src.api.services.user_config import UserConfigService, WebcamConfigModel
from src.cameras.detection.cam_singleton import get_or_create_cams
from src.cameras.multicam_manager.cv_camera_manager import OpenCVCameraManager
async de... | null |
143,718 | import logging
import cv2
from fastapi import APIRouter
from pydantic import BaseModel
from src.api.services.user_config import UserConfigService, WebcamConfigModel
from src.cameras.detection.cam_singleton import get_or_create_cams
from src.cameras.multicam_manager.cv_camera_manager import OpenCVCameraManager
logger = ... | null |
143,719 | import logging
import cv2
from fastapi import APIRouter
from pydantic import BaseModel
from src.api.services.user_config import UserConfigService, WebcamConfigModel
from src.cameras.detection.cam_singleton import get_or_create_cams
from src.cameras.multicam_manager.cv_camera_manager import OpenCVCameraManager
logger = ... | null |
143,720 | import logging
import cv2
from fastapi import APIRouter
from pydantic import BaseModel
from src.api.services.user_config import UserConfigService, WebcamConfigModel
from src.cameras.detection.cam_singleton import get_or_create_cams
from src.cameras.multicam_manager.cv_camera_manager import OpenCVCameraManager
async de... | null |
143,721 | import logging
import cv2
from fastapi import APIRouter
from pydantic import BaseModel
from src.api.services.user_config import UserConfigService, WebcamConfigModel
from src.cameras.detection.cam_singleton import get_or_create_cams
from src.cameras.multicam_manager.cv_camera_manager import OpenCVCameraManager
async de... | null |
143,722 | import logging
import time
import cv2
import numpy as np
from fastapi import APIRouter, WebSocket
from src.cameras.capture.dataclasses.frame_payload import FramePayload
async def websocket_send(web_socket: WebSocket, input_payload: FramePayload):
if not input_payload.success:
return
success, frame = cv... | null |
143,723 | import logging
import time
import cv2
import numpy as np
from fastapi import APIRouter, WebSocket
from src.cameras.capture.dataclasses.frame_payload import FramePayload
async def preview_webcam(web_socket: WebSocket):
await web_socket.accept()
while True:
last_read = time.perf_counter()
byte_da... | null |
143,724 | from fastapi import APIRouter
async def hello():
response_string = "hello :D"
print(f"response string: {response_string}")
return response_string | null |
143,725 | import uvicorn
from fastapi import FastAPI
from src.api.middleware.cors import cors
from src.api.routes import enabled_routers
def create_app(*args, **kwargs):
_app = FastAPI()
cors(_app)
for router in enabled_routers:
_app.include_router(router)
return _app | null |
143,726 | import logging
from pathlib import Path
from pydantic import BaseModel
from src.config.home_dir import get_session_folder_path
def get_camera_name(camera_id: str):
return "camera_" + camera_id | null |
143,727 | from pathlib import Path
from typing import Union
from freemocap.core_processes.capture_volume_calibration.anipose_camera_calibration.anipose_camera_calibrator import (
AniposeCameraCalibrator,
)
from freemocap.core_processes.capture_volume_calibration.charuco_stuff.charuco_board_definition import (
CharucoBoar... | null |
143,728 | import logging
from pathlib import Path
from typing import Optional, Union
from freemocap.core_processes.export_data.blender_stuff.export_to_blender import export_to_blender
from freemocap.core_processes.process_motion_capture_videos.process_recording_folder import process_recording_folder
from freemocap.data_layer.rec... | null |
143,729 | import argparse
import argparse
import datetime
import inspect
import os
import numpy as np
from PIL import Image
from omegaconf import OmegaConf
from collections import OrderedDict
import torch
import random
from diffusers import AutoencoderKL, DDIMScheduler, UniPCMultistepScheduler
from transformers import CLIPTextMo... | null |
143,730 | import argparse
import imageio
import os, datetime
import numpy as np
import gradio as gr
from PIL import Image
from subprocess import PIPE, run
savedir = f"demo/outputs"
def animate(reference_image, motion_sequence, seed, steps, guidance_scale):
time_str = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
... | null |
143,731 | import argparse
import imageio
import os, datetime
import numpy as np
import gradio as gr
from PIL import Image
from subprocess import PIPE, run
def read_video(video, size=512):
size = int(size)
reader = imageio.get_reader(video)
# fps = reader.get_meta_data()['fps']
frames = []
... | null |
143,732 | import argparse
import imageio
import os, datetime
import numpy as np
import gradio as gr
from PIL import Image
from subprocess import PIPE, run
def read_image(image, size=512):
img = np.array(Image.fromarray(image).resize((size, size)))
return img | null |
143,733 | import argparse
import imageio
import numpy as np
import gradio as gr
from PIL import Image
from demo.animate import MagicAnimate
animator = MagicAnimate()
def animate(reference_image, motion_sequence_state, seed, steps, guidance_scale):
return animator(reference_image, motion_sequence_state, seed, steps, guidance... | null |
143,734 | import argparse
import imageio
import numpy as np
import gradio as gr
from PIL import Image
from demo.animate import MagicAnimate
def read_video(video):
reader = imageio.get_reader(video)
fps = reader.get_meta_data()['fps']
return video | null |
143,735 | import argparse
import imageio
import numpy as np
import gradio as gr
from PIL import Image
from demo.animate import MagicAnimate
def read_image(image, size=512):
return np.array(Image.fromarray(image).resize((size, size))) | null |
143,736 | import argparse
import datetime
import inspect
import os
import random
import numpy as np
from PIL import Image
from omegaconf import OmegaConf
from collections import OrderedDict
import torch
import torch.distributed as dist
from diffusers import AutoencoderKL, DDIMScheduler, UniPCMultistepScheduler
from tqdm import t... | null |
143,737 | import numpy as np
from typing import Callable, Optional, List
def uniform(
step: int = ...,
num_steps: Optional[int] = None,
num_frames: int = ...,
context_size: Optional[int] = None,
context_stride: int = 3,
context_overlap: int = 4,
closed_loop: bool = True,
):
def get_context_scheduler(... | null |
143,738 | import numpy as np
from typing import Callable, Optional, List
def get_total_steps(
scheduler,
timesteps: List[int],
num_steps: Optional[int] = None,
num_frames: int = ...,
context_size: Optional[int] = None,
context_stride: int = 3,
context_overlap: int = 4,
closed_loop: bool = True,
)... | null |
143,739 | from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import numpy as np
import PIL.Image
import torch
from diffusers import StableDiffusionControlNetPipeline
from diffusers.models import ControlNetModel
from diffusers.models.attention import BasicTransformerBlock
from diffusers.models.unet_2d_blocks imp... | null |
143,740 | from dataclasses import dataclass
import torch
import torch.nn.functional as F
from torch import nn
from diffusers.utils import BaseOutput
from diffusers.utils.import_utils import is_xformers_available
from diffusers.models.attention import FeedForward
from magicanimate.models.orig_attention import CrossAttention
from ... | null |
143,741 | from dataclasses import dataclass
import torch
import torch.nn.functional as F
from torch import nn
from diffusers.utils import BaseOutput
from diffusers.utils.import_utils import is_xformers_available
from diffusers.models.attention import FeedForward
from magicanimate.models.orig_attention import CrossAttention
from ... | null |
143,742 | import torch
from torch import nn
from .attention import Transformer3DModel
from .resnet import Downsample3D, ResnetBlock3D, Upsample3D
from .motion_module import get_motion_module
class CrossAttnDownBlock3D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
... | null |
143,743 | import torch
from torch import nn
from .attention import Transformer3DModel
from .resnet import Downsample3D, ResnetBlock3D, Upsample3D
from .motion_module import get_motion_module
class CrossAttnUpBlock3D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
prev_outp... | null |
143,744 | import math
from typing import Optional
import numpy as np
import torch
from torch import nn
The provided code snippet includes necessary dependencies for implementing the `get_timestep_embedding` function. Write a Python function `def get_timestep_embedding( timesteps: torch.Tensor, embedding_dim: int, fl... | This matches the implementation in Denoising Diffusion Probabilistic Models: Create sinusoidal timestep embeddings. :param timesteps: a 1-D Tensor of N indices, one per batch element. These may be fractional. :param embedding_dim: the dimension of the output. :param max_period: controls the minimum frequency of the emb... |
143,745 | import math
from typing import Optional
import numpy as np
import torch
from torch import nn
def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
if embed_dim % 2 != 0:
raise ValueError("embed_dim must be divisible by 2")
# use half of dimensions to encode grid_h
emb_h = get_1d_sincos_pos_embed_f... | grid_size: int of the grid height and width return: pos_embed: [grid_size*grid_size, embed_dim] or [1+grid_size*grid_size, embed_dim] (w/ or w/o cls_token) |
143,746 | from dataclasses import dataclass
from typing import Any, Dict, List, Optional, Tuple, Union
import torch
from torch import nn
from torch.nn import functional as F
from diffusers.configuration_utils import ConfigMixin, register_to_config
from diffusers.utils import BaseOutput, logging
from .embeddings import TimestepEm... | null |
143,747 | import os
import imageio
import numpy as np
import torch
import torchvision
from PIL import Image
from typing import Union
from tqdm import tqdm
from einops import rearrange
def save_videos_grid(videos: torch.Tensor, path: str, rescale=False, n_rows=6, fps=25):
videos = rearrange(videos, "b c t h w -> t b c h w")
... | null |
143,748 | import os
import imageio
import numpy as np
import torch
import torchvision
from PIL import Image
from typing import Union
from tqdm import tqdm
from einops import rearrange
def save_images_grid(images: torch.Tensor, path: str):
assert images.shape[2] == 1 # no time dimension
images = images.squeeze(2)
gri... | null |
143,749 | import os
import imageio
import numpy as np
import torch
import torchvision
from PIL import Image
from typing import Union
from tqdm import tqdm
from einops import rearrange
def ddim_loop(pipeline, ddim_scheduler, latent, num_inv_steps, prompt):
context = init_prompt(prompt, pipeline)
uncond_embeddings, cond_em... | null |
143,750 | import os
import imageio
import numpy as np
import torch
import torchvision
from PIL import Image
from typing import Union
from tqdm import tqdm
from einops import rearrange
def video2images(path, step=4, length=16, start=0):
reader = imageio.get_reader(path)
frames = []
for frame in reader:
frames... | null |
143,751 | import os
import imageio
import numpy as np
import torch
import torchvision
from PIL import Image
from typing import Union
from tqdm import tqdm
from einops import rearrange
def images2video(video, path, fps=8):
imageio.mimsave(path, video, fps=fps)
return | null |
143,752 | import os
import imageio
import numpy as np
import torch
import torchvision
from PIL import Image
from typing import Union
from tqdm import tqdm
from einops import rearrange
tensor_interpolation = None
def get_tensor_interpolation_method():
return tensor_interpolation | null |
143,753 | import os
import imageio
import numpy as np
import torch
import torchvision
from PIL import Image
from typing import Union
from tqdm import tqdm
from einops import rearrange
tensor_interpolation = None
def linear(v1, v2, t):
return (1.0 - t) * v1 + t * v2
def slerp(
v0: torch.Tensor, v1: torch.Tensor, t: float,... | null |
143,754 | import os
import socket
import warnings
import torch
from torch import distributed as dist
def synchronize():
if dist.is_initialized():
dist.barrier() | null |
143,755 | import math
from typing import List
from collections import defaultdict
import torch
import torch.nn as nn
import torch.nn.functional as F
The provided code snippet includes necessary dependencies for implementing the `conv3x3` function. Write a Python function `def conv3x3(in_planes, out_planes, stride=1, groups=1, d... | 3x3 convolution with padding |
143,756 | import math
from typing import List
from collections import defaultdict
import torch
import torch.nn as nn
import torch.nn.functional as F
The provided code snippet includes necessary dependencies for implementing the `conv1x1` function. Write a Python function `def conv1x1(in_planes, out_planes, stride=1)` to solve t... | 1x1 convolution |
143,757 | import math
from typing import List
from collections import defaultdict
import torch
import torch.nn as nn
import torch.nn.functional as F
def generate_square_subsequent_mask(sz):
mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(... | null |
143,758 | import math
from typing import List
from collections import defaultdict
import torch
import torch.nn as nn
import torch.nn.functional as F
class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout... | null |
143,759 | import math
from typing import List
from collections import defaultdict
import torch
import torch.nn as nn
import torch.nn.functional as F
class OCR(nn.Module):
def __init__(self, dictionary, max_len):
super(OCR, self).__init__()
self.max_len = max_len
self.dictionary = dictionary
se... | null |
143,760 | import einops
import numpy as np
import torch
import torch.nn as nn
def fixed_pos_embedding(x):
seq_len, dim = x.shape
inv_freq = 1.0 / (10000 ** (torch.arange(0, dim) / dim))
sinusoid_inp = (
torch.einsum("i , j -> i j", torch.arange(0, seq_len, dtype=torch.float), inv_freq).to(x)
)
return... | null |
143,761 | import einops
import numpy as np
import torch
import torch.nn as nn
def rotate_every_two(x):
def duplicate_interleave(m):
def apply_rotary_pos_emb(x, sin, cos, scale=1):
sin, cos = map(lambda t: duplicate_interleave(t * scale), (sin, cos))
# einsum notation for lambda t: repeat(t[offset:x.shape[1]+offset,:], "... | null |
143,762 | import einops
import numpy as np
import torch
import torch.nn as nn
def rotate_every_two(x):
def duplicate_interleave(m):
def apply_rotary_pos_emb2d(x, sin, cos, scale=1):
breakpoint()
sin, cos = map(lambda t: duplicate_interleave(t * scale), (sin, cos))
# einsum notation for lambda t: repeat(t[offset:x.sh... | null |
143,763 | import os
import math
import shutil
import cv2
from typing import List, Tuple, Optional
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, AvgMeter, chunks
from ..utils.bubble import is_ignore
... | 3x3 convolution with padding |
143,764 | import os
import math
import shutil
import cv2
from typing import List, Tuple, Optional
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, AvgMeter, chunks
from ..utils.bubble import is_ignore
... | 1x1 convolution |
143,765 | import os
import math
import shutil
import cv2
from typing import List, Tuple, Optional
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, AvgMeter, chunks
from ..utils.bubble import is_ignore
c... | null |
143,766 | import os
import math
import shutil
import cv2
from typing import List, Tuple, Optional
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, AvgMeter, chunks
from ..utils.bubble import is_ignore
c... | null |
143,767 | import itertools
import math
from typing import Callable, List, Set, Optional, Tuple, Union
from collections import defaultdict, Counter
import os
import shutil
import cv2
from PIL import Image
import numpy as np
import einops
import networkx as nx
from shapely.geometry import Polygon
import torch
import torch.nn as nn... | null |
143,768 | import math
from typing import Callable, List, Optional, Tuple, Union
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .xpos_relative_position import XPOS
from .common import OfflineOCR
from ..... | null |
143,769 | import math
from typing import Callable, List, Optional, Tuple, Union
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .xpos_relative_position import XPOS
from .common import OfflineOCR
from ..... | null |
143,770 | import math
from typing import Callable, List, Optional, Tuple, Union
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .xpos_relative_position import XPOS
from .common import OfflineOCR
from ..... | null |
143,771 | import math
from typing import Callable, List, Optional, Tuple, Union
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .xpos_relative_position import XPOS
from .common import OfflineOCR
from ..... | null |
143,772 | import math
from typing import Callable, List, Optional, Tuple, Union
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .xpos_relative_position import XPOS
from .common import OfflineOCR
from ..... | null |
143,773 | import math
from typing import List
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, chunks
from ..utils.bubble import is... | 3x3 convolution with padding |
143,774 | import math
from typing import List
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, chunks
from ..utils.bubble import is... | 1x1 convolution |
143,775 | import math
from typing import List
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, chunks
from ..utils.bubble import is... | null |
143,776 | import math
from typing import List
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, chunks
from ..utils.bubble import is... | null |
143,777 | import math
from typing import List
from collections import defaultdict
import os
import shutil
import cv2
import numpy as np
import einops
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import OfflineOCR
from ..utils import TextBlock, Quadrilateral, chunks
from ..utils.bubble import is... | null |
143,778 | from typing import Tuple, List
import numpy as np
import cv2
import math
from tqdm import tqdm
from shapely.geometry import Polygon
from ..utils import Quadrilateral, image_resize
from pydensecrf.utils import compute_unary, unary_from_softmax
import pydensecrf.densecrf as dcrf
def save_rgb(fn, img):
if len(img.sha... | null |
143,779 | from typing import Tuple, List
import numpy as np
import cv2
import math
from tqdm import tqdm
from shapely.geometry import Polygon
from ..utils import Quadrilateral, image_resize
from pydensecrf.utils import compute_unary, unary_from_softmax
import pydensecrf.densecrf as dcrf
def area_overlap(x1, y1, w1, h1, x2, y2, ... | null |
143,780 | from typing import Tuple, List
import numpy as np
import cv2
import math
from tqdm import tqdm
from shapely.geometry import Polygon
from ..utils import Quadrilateral, image_resize
def dist(x1, y1, x2, y2):
return math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
from pydensecrf.utils import compute_unary, un... | null |
143,781 | from typing import Tuple, List
import numpy as np
import cv2
import math
from tqdm import tqdm
from shapely.geometry import Polygon
from ..utils import Quadrilateral, image_resize
from pydensecrf.utils import compute_unary, unary_from_softmax
import pydensecrf.densecrf as dcrf
def complete_mask_fill(text_lines: List[T... | null |
143,782 | from typing import Tuple, List
import numpy as np
import cv2
import math
from tqdm import tqdm
from shapely.geometry import Polygon
from ..utils import Quadrilateral, image_resize
def extend_rect(x, y, w, h, max_x, max_y, extend_size):
from pydensecrf.utils import compute_unary, unary_from_softmax
import pydensecrf.den... | null |
143,783 | from typing import Tuple, List
import numpy as np
import cv2
import math
from tqdm import tqdm
from shapely.geometry import Polygon
from ..utils import Quadrilateral, image_resize
from pydensecrf.utils import compute_unary, unary_from_softmax
import pydensecrf.densecrf as dcrf
def unsharp(image):
gaussian_3 = cv2.... | null |
143,784 | import argparse
import os
from urllib.parse import unquote
from .detection import DETECTORS
from .ocr import OCRS
from .inpainting import INPAINTERS
from .translators import VALID_LANGUAGES, TRANSLATORS, TranslatorChain
from .upscaling import UPSCALERS
from .colorization import COLORIZERS
from .save import OUTPUT_FORMA... | null |
143,785 | import argparse
import os
from urllib.parse import unquote
from .detection import DETECTORS
from .ocr import OCRS
from .inpainting import INPAINTERS
from .translators import VALID_LANGUAGES, TRANSLATORS, TranslatorChain
from .upscaling import UPSCALERS
from .colorization import COLORIZERS
from .save import OUTPUT_FORMA... | null |
143,786 | import argparse
import os
from urllib.parse import unquote
from .detection import DETECTORS
from .ocr import OCRS
from .inpainting import INPAINTERS
from .translators import VALID_LANGUAGES, TRANSLATORS, TranslatorChain
from .upscaling import UPSCALERS
from .colorization import COLORIZERS
from .save import OUTPUT_FORMA... | null |
143,787 | import os
import asyncio
import logging
from argparse import Namespace
from .manga_translator import (
MangaTranslator,
MangaTranslatorWeb,
MangaTranslatorWS,
MangaTranslatorAPI,
set_main_logger,
)
from .args import parser
from .utils import (
BASE_PATH,
init_logging,
get_logger,
set... | null |
143,788 | import numpy as np
import cv2
The provided code snippet includes necessary dependencies for implementing the `variable_to_cv2_image` function. Write a Python function `def variable_to_cv2_image(varim)` to solve the following problem:
r"""Converts a torch.autograd.Variable to an OpenCV image Args: varim: a torch.autogr... | r"""Converts a torch.autograd.Variable to an OpenCV image Args: varim: a torch.autograd.Variable |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.