language stringclasses 4
values | source_code stringlengths 21 986k | test_code stringlengths 125 698k | repo_name stringclasses 95
values |
|---|---|---|---|
python | """Automatically generated file.
To update, run python3 -m script.hassfest
"""
FLOWS = {
"helper": [
"derivative",
"filter",
"generic_hygrostat",
"generic_thermostat",
"group",
"history_stats",
"integration",
"min_max",
"mold_indicator",
... | """Test the devolo_home_control config flow."""
from unittest.mock import MagicMock
from homeassistant import config_entries
from homeassistant.components.devolo_home_control.const import DOMAIN
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistan... | core |
python | import logging
import time
from abc import ABC, abstractmethod
from collections import deque
from collections.abc import Mapping, MutableMapping, Sequence
from concurrent.futures import Future
from functools import partial
from typing import Any, Deque, NamedTuple
from arroyo.backends.kafka import KafkaPayload
from ar... | from unittest import mock
from arroyo import Topic
from arroyo.backends.kafka import KafkaPayload
from django.test import override_settings
from sentry_kafka_schemas.schema_types.monitors_clock_tasks_v1 import MarkTimeout
from sentry.monitors.clock_tasks.producer import MONITORS_CLOCK_TASKS_CODEC, produce_task
@ove... | sentry |
python | """Support for Palazzetti buttons."""
from __future__ import annotations
from pypalazzetti.exceptions import CommunicationError
from homeassistant.components.button import ButtonEntity
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.enti... | """Test the Teslemetry button platform."""
from unittest.mock import patch
import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS
from homeassistant.const import ATTR_ENTITY_ID, Platform
from homeassistant.core import HomeAssist... | core |
python | """Init file for Home Assistant."""
| """Tests for the ness_alarm component."""
from unittest.mock import MagicMock, patch
from nessclient import ArmingMode, ArmingState
import pytest
from homeassistant.components import alarm_control_panel
from homeassistant.components.alarm_control_panel import AlarmControlPanelState
from homeassistant.components.ness... | core |
python | """
Module to manage filesystem snapshots with snapper
.. versionadded:: 2016.11.0
:codeauthor: Duncan Mac-Vicar P. <dmacvicar@suse.de>
:codeauthor: Pablo Suárez Hernández <psuarezhernandez@suse.de>
:depends: ``dbus`` Python module.
:depends: ``snapper`` http://snapper.io, available in most distros... | """
Unit tests for the Snapper module
:codeauthor: Duncan Mac-Vicar P. <dmacvicar@suse.de>
:codeauthor: Pablo Suárez Hernández <psuarezhernandez@suse.de>
"""
import pytest
import salt.modules.snapper as snapper
import salt.utils.files
import salt.utils.platform
from salt.exceptions import CommandExecutionError... | salt |
python | """Init file for Home Assistant."""
| """Test bluesound integration."""
from pyblu.errors import PlayerUnreachableError
from homeassistant.config_entries import ConfigEntryState
from homeassistant.core import HomeAssistant
from .conftest import PlayerMocks
from tests.common import MockConfigEntry
async def test_setup_entry(
hass: HomeAssistant, s... | core |
python | """OpenAI chat wrapper."""
from __future__ import annotations
import base64
import json
import logging
import os
import re
import ssl
import sys
import warnings
from collections.abc import (
AsyncIterator,
Awaitable,
Callable,
Iterator,
Mapping,
Sequence,
)
from functools import partial
from i... | """Test Base Schema of documents."""
from collections.abc import Iterator
import pytest
from typing_extensions import override
from langchain_core.document_loaders.base import BaseBlobParser, BaseLoader
from langchain_core.documents import Document
from langchain_core.documents.base import Blob
def test_base_blob_... | langchain |
python | import copy
from decimal import Decimal
from django.apps.registry import Apps
from django.db import NotSupportedError
from django.db.backends.base.schema import BaseDatabaseSchemaEditor
from django.db.backends.ddl_references import Statement
from django.db.backends.utils import strip_quotes
from django.db.models impor... | import unittest
from django.db import connection
from django.test import TestCase
@unittest.skipUnless(connection.vendor == "mysql", "MySQL tests")
class SchemaEditorTests(TestCase):
def test_quote_value(self):
import MySQLdb
editor = connection.schema_editor()
tested_values = [
... | django |
python | """Provides diagnostics for Palazzetti."""
from __future__ import annotations
from typing import Any
from homeassistant.core import HomeAssistant
from .coordinator import PalazzettiConfigEntry
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: PalazzettiConfigEntry
) -> dict[str, Any]:
... | """Tests for the diagnostics data provided by the Ohme integration."""
from unittest.mock import MagicMock
from syrupy.assertion import SnapshotAssertion
from homeassistant.core import HomeAssistant
from . import setup_integration
from tests.common import MockConfigEntry
from tests.components.diagnostics import ge... | core |
python | from .enums import BasePermissionEnum
def is_app(context):
return bool(context.app)
def is_user(context):
user = context.user
return user and user.is_active
def is_staff_user(context):
return is_user(context) and context.user.is_staff
class AuthorizationFilters(BasePermissionEnum):
# Grants ... | from unittest.mock import ANY, patch
import pytest
from ....order.models import Order
from ..filters import (
_filter_by_customer_full_name,
_filter_customer_by_email_first_or_last_name,
filter_customer,
)
@pytest.fixture
def similar_customers_with_orders(order, customer_user, customer_user2, channel_US... | saleor |
python | """
Watch files and translate the changes into salt events.
.. versionadded:: 2019.2.0
:depends: - watchdog Python module >= 0.8.3
"""
import collections
import logging
import salt.utils.beacons
try:
# pylint: disable=no-name-in-module
from watchdog.events import FileSystemEventHandler
from watchdog... | import pytest
import salt.utils.platform
from . import normalize_ret
pytestmark = [
pytest.mark.windows_whitelisted,
pytest.mark.core_test,
]
def test_watch_in(state, state_tree):
"""
test watch_in requisite when there is a success
"""
sls_contents = """
return_changes:
test.succe... | salt |
python | """Track recorder run history."""
from __future__ import annotations
from datetime import datetime
from sqlalchemy.orm.session import Session
from homeassistant.util import dt as dt_util
from ..db_schema import RecorderRuns
class RecorderRunsManager:
"""Track recorder run history."""
def __init__(self) ... | """The tests for climate recorder."""
from __future__ import annotations
from datetime import timedelta
from unittest.mock import patch
import pytest
from homeassistant.components import climate
from homeassistant.components.climate import (
ATTR_FAN_MODES,
ATTR_HVAC_MODES,
ATTR_MAX_HUMIDITY,
ATTR_M... | core |
python | """
Module for managing timezone on Windows systems.
"""
import logging
from datetime import datetime
from salt.exceptions import CommandExecutionError
try:
import pytz
HAS_PYTZ = True
except ImportError:
HAS_PYTZ = False
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualna... | """
:codeauthor: Jayesh Kariya <jayeshk@saltstack.com>
"""
import pytest
import salt.modules.win_timezone as win_timezone
from salt.exceptions import CommandExecutionError
from tests.support.mock import MagicMock, patch
pytestmark = [
pytest.mark.skipif(not win_timezone.HAS_PYTZ, reason="This test requires p... | salt |
python | """
Service support for RHEL-based systems, including support for both upstart and sysvinit
.. important::
If you feel that Salt should be using this module to manage services on a
minion, and it is using a different module (or gives an error similar to
*'service.start' is not available*), see :ref:`here
... | """
:codeauthor: Jayesh Kariya <jayeshk@saltstack.com>
Test cases for salt.modules.rh_service
"""
import textwrap
import pytest
import salt.modules.rh_service as rh_service
from tests.support.mock import MagicMock, patch
@pytest.fixture
def RET():
return [
"hostname",
"mountall",
... | salt |
python | """Support for Palazzetti sensors."""
from dataclasses import dataclass
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorEntityDescription,
SensorStateClass,
)
from homeassistant.const import UnitOfLength, UnitOfMass, UnitOfTemperature
from homeassistant.core import... | """Tests for the Start.ca sensor platform."""
from http import HTTPStatus
from homeassistant.components.startca.sensor import StartcaData
from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, PERCENTAGE, UnitOfInformation
from homeassistant.core import HomeAssistant
from homeassistant.helpers.aiohttp_client impor... | core |
python | """The Recorder websocket API."""
from __future__ import annotations
import asyncio
from datetime import datetime as dt
import logging
from typing import Any, Literal, cast
import voluptuous as vol
from homeassistant.components import websocket_api
from homeassistant.components.websocket_api import messages
from ho... | """Test Trace websocket API."""
import asyncio
from collections import defaultdict
import json
from typing import Any
from unittest.mock import patch
import pytest
from pytest_unordered import unordered
from homeassistant.components.trace.const import DEFAULT_STORED_TRACES
from homeassistant.const import EVENT_HOMEA... | core |
python | """OpenAI chat wrapper."""
from __future__ import annotations
import base64
import json
import logging
import os
import re
import ssl
import sys
import warnings
from collections.abc import (
AsyncIterator,
Awaitable,
Callable,
Iterator,
Mapping,
Sequence,
)
from functools import partial
from i... | import pytest
from langchain_classic.evaluation import ExactMatchStringEvaluator
@pytest.fixture
def exact_match_string_evaluator() -> ExactMatchStringEvaluator:
"""Create an ExactMatchStringEvaluator with default configuration."""
return ExactMatchStringEvaluator()
@pytest.fixture
def exact_match_string_e... | langchain |
python | from __future__ import annotations
import json
from collections.abc import Callable, Generator
from typing import Any, Literal
from starlette import status
from starlette._utils import is_async_callable
from starlette.concurrency import run_in_threadpool
from starlette.exceptions import HTTPException
from starlette.r... | from collections.abc import Iterator
import pytest
from starlette.endpoints import HTTPEndpoint, WebSocketEndpoint
from starlette.requests import Request
from starlette.responses import PlainTextResponse
from starlette.routing import Route, Router
from starlette.testclient import TestClient
from starlette.websockets ... | starlette |
python | from typing import Any, Callable, Final, Optional
import boto3
from botocore.exceptions import ClientError
from moto.stepfunctions.parser.api import HistoryEventType, TaskFailedEventDetails
from moto.stepfunctions.parser.asl.component.common.error_name.custom_error_name import (
CustomErrorName,
)
from moto.stepf... | """Unit tests for glue-supported APIs."""
import json
from random import randint
from uuid import uuid4
import boto3
import pytest
from botocore.client import ClientError
from moto import mock_aws
@mock_aws
def test_create_job():
client = create_glue_client()
job_name = str(uuid4())
response = client.c... | moto |
python | """Optical character recognition processing of seven segments displays."""
from __future__ import annotations
import io
import logging
import os
import subprocess
from PIL import Image
import voluptuous as vol
from homeassistant.components.image_processing import (
PLATFORM_SCHEMA as IMAGE_PROCESSING_PLATFORM_S... | """The tests for the openalpr cloud platform."""
from unittest.mock import PropertyMock, patch
import pytest
from homeassistant.components import camera, image_processing as ip
from homeassistant.components.openalpr_cloud.image_processing import OPENALPR_API_URL
from homeassistant.core import Event, HomeAssistant
fr... | core |
python | """Support for TPLink Omada device firmware updates."""
from __future__ import annotations
from datetime import timedelta
from typing import Any, NamedTuple
from tplink_omada_client import OmadaSiteClient
from tplink_omada_client.devices import OmadaFirmwareUpdate, OmadaListDevice
from tplink_omada_client.exceptions... | """Tests for the Openhome update platform."""
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from homeassistant.components.openhome.const import DOMAIN
from homeassistant.components.update import (
ATTR_INSTALLED_VERSION,
ATTR_LATEST_VERSION,
ATTR_RELEASE_SUMMARY,
ATTR_RELEASE_UR... | core |
python | from __future__ import annotations
from types import TracebackType
from typing import Any
import orjson
from requests.exceptions import RequestException
from sentry import http
from .constants import ACCESS_TOKEN_URL
class FlyApiError(Exception):
def __init__(self, message: str | bytes = "", status: int = 0) ... | import re
from dataclasses import asdict
from datetime import UTC, datetime, timedelta
from unittest import mock
import orjson
import pytest
import responses
from django.test import override_settings
from django.utils import timezone
from requests import Request
from responses import matchers
from sentry.constants im... | sentry |
python | """
Support for OSQuery - https://osquery.io.
.. versionadded:: 2015.8.0
"""
import logging
import salt.utils.json
import salt.utils.path
import salt.utils.platform
log = logging.getLogger(__name__)
__func_alias__ = {
"file_": "file",
"hash_": "hash",
"time_": "time",
}
__virtualname__ = "osquery"
... | """
:codeauthor: Gareth J. Greenaway <gareth@saltstack.com>
Test cases for salt.modules.osquery
"""
import pytest
import salt.modules.osquery as osquery
from tests.support.mock import MagicMock, patch
@pytest.fixture
def configure_loader_modules():
return {osquery: {}}
def test_version():
"""
... | salt |
python | """Helpers for the CloudFlare integration."""
import pycfdns
def get_zone_id(target_zone_name: str, zones: list[pycfdns.ZoneModel]) -> str | None:
"""Get the zone ID for the target zone name."""
for zone in zones:
if zone["name"] == target_zone_name:
return zone["id"]
return None
| """The test for sensor helpers."""
import pytest
from homeassistant.components.sensor import SensorDeviceClass
from homeassistant.components.sensor.helpers import async_parse_date_datetime
def test_async_parse_datetime(caplog: pytest.LogCaptureFixture) -> None:
"""Test async_parse_date_datetime."""
entity_i... | core |
python | """Init file for Home Assistant."""
| """Test Subaru component setup and updates."""
from unittest.mock import patch
from subarulink import InvalidCredentials, SubaruException
from homeassistant.components.homeassistant import (
DOMAIN as HA_DOMAIN,
SERVICE_UPDATE_ENTITY,
)
from homeassistant.components.subaru.const import DOMAIN
from homeassist... | core |
python | """Automatically generated file.
To update, run python3 -m script.hassfest
"""
FLOWS = {
"helper": [
"derivative",
"filter",
"generic_hygrostat",
"generic_thermostat",
"group",
"history_stats",
"integration",
"min_max",
"mold_indicator",
... | """Tests for the kraken config_flow."""
from unittest.mock import patch
from homeassistant.components.kraken.const import CONF_TRACKED_ASSET_PAIRS, DOMAIN
from homeassistant.const import CONF_SCAN_INTERVAL
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResultType
from .con... | core |
python | import graphene
from django.core.exceptions import ValidationError
from ....giftcard import events
from ....giftcard.error_codes import GiftCardErrorCode
from ....permission.enums import GiftcardPermissions
from ....webhook.event_types import WebhookEventAsyncType
from ...app.dataloaders import get_app_promise
from ..... | import datetime
import json
from unittest import mock
import graphene
import pytest
from django.utils.functional import SimpleLazyObject
from freezegun import freeze_time
from .....core.utils.json_serializer import CustomJsonEncoder
from .....giftcard import GiftCardEvents
from .....giftcard.error_codes import GiftCa... | saleor |
python | """Switch platform for Growatt."""
from __future__ import annotations
from dataclasses import dataclass
import logging
from typing import Any
from growattServer import GrowattV1ApiError
from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
from homeassistant.const import EntityCategory
f... | """Test the NUT switch platform."""
import json
from unittest.mock import AsyncMock
import pytest
from homeassistant.components.nut.const import DOMAIN, INTEGRATION_SUPPORTED_COMMANDS
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE... | core |
python | """Init file for Home Assistant."""
| """Tests of the initialization of the balboa integration."""
from unittest.mock import MagicMock
from homeassistant.components.balboa.const import DOMAIN
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
from . import TEST... | core |
python | import random
import string
from contextlib import contextmanager
from moto.utilities import id_generator as moto_id_generator
from moto.utilities.id_generator import MotoIdManager, ResourceIdentifier, moto_id
from moto.utilities.id_generator import ResourceIdentifier as MotoResourceIdentifier
from localstack.utils.s... | import pytest
from localstack.constants import TAG_KEY_CUSTOM_ID
from localstack.services.cloudformation.engine.entities import StackIdentifier
from localstack.testing.config import TEST_AWS_ACCOUNT_ID, TEST_AWS_REGION_NAME
from localstack.utils.id_generator import (
ResourceIdentifier,
generate_short_uid,
... | localstack |
python | # Copyright 2016 Open Source Robotics Foundation, Inc.
#
# 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
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | # Copyright 2020 Open Source Robotics Foundation, Inc.
#
# 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
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | rclpy |
python | """Media player support for Android TV Remote."""
from __future__ import annotations
import asyncio
from typing import Any
from androidtvremote2 import AndroidTVRemote, ConnectionClosed, VolumeInfo
from homeassistant.components.media_player import (
BrowseMedia,
MediaClass,
MediaPlayerDeviceClass,
M... | """The tests for the LG webOS TV media player platform."""
from datetime import timedelta
from http import HTTPStatus
from aiowebostv import WebOsTvPairError
from freezegun.api import FrozenDateTimeFactory
import pytest
from syrupy.assertion import SnapshotAssertion
from syrupy.filters import props
from homeassistan... | core |
python | """Init file for Home Assistant."""
| """Test the Network Configuration."""
from __future__ import annotations
from ipaddress import IPv4Address
from typing import Any
from unittest.mock import MagicMock, Mock, patch
import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.components import network
from homeassistant.components.n... | core |
python | """Support for Palazzetti sensors."""
from dataclasses import dataclass
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorEntityDescription,
SensorStateClass,
)
from homeassistant.const import UnitOfLength, UnitOfMass, UnitOfTemperature
from homeassistant.core import... | """Test for Arve sensors."""
from unittest.mock import MagicMock
from syrupy.assertion import SnapshotAssertion
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from . import async_init_integration
from tests.common import MockConfigEntry
SENSORS = (
"air_qu... | core |
python | """Support for Palazzetti sensors."""
from dataclasses import dataclass
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorEntityDescription,
SensorStateClass,
)
from homeassistant.const import UnitOfLength, UnitOfMass, UnitOfTemperature
from homeassistant.core import... | """Test sensor entities for the LetPot integration."""
from unittest.mock import MagicMock, patch
from syrupy.assertion import SnapshotAssertion
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from . import setup_integrati... | core |
python | from typing import Any
import sentry_sdk
from django.db import IntegrityError, router, transaction
from django.db.models import F
from django.utils import timezone
from drf_spectacular.utils import extend_schema
from rest_framework.request import Request
from rest_framework.response import Response
from sentry import... | from __future__ import annotations
from datetime import datetime, timedelta
from typing import Any
from unittest import mock
from urllib.parse import parse_qs, urlsplit
import pytest
from django.urls import reverse
from django.utils import timezone
from sentry.dashboards.endpoints.organization_dashboards import Preb... | sentry |
python | """Script to convert a device diagnostics file to a fixture."""
from __future__ import annotations
import argparse
import json
from pathlib import Path
from typing import Any
from homeassistant.util import slugify
def get_arguments() -> argparse.Namespace:
"""Get parsed passed in arguments."""
parser = arg... | """Test convert_device_diagnostics_to_fixture script."""
import copy
import json
from pathlib import Path
import sys
from unittest.mock import patch
import pytest
from homeassistant.components.zwave_js.scripts.convert_device_diagnostics_to_fixture import (
extract_fixture_data,
get_fixtures_dir_path,
loa... | core |
python | # -*- coding: utf-8 -*-
"""
Copyright (C) 2024 Xiaomi Corporation.
The ownership and intellectual property rights of Xiaomi Home Assistant
Integration and related Xiaomi cloud service API interface provided under this
license, including source code and object code (collectively, "Licensed Work"),
are owned by Xiaomi. ... | # -*- coding: utf-8 -*-
"""Unit test for miot_common.py."""
import pytest
# pylint: disable=import-outside-toplevel, unused-argument
@pytest.mark.github
def test_miot_matcher():
from miot.common import MIoTMatcher
matcher: MIoTMatcher = MIoTMatcher()
# Add
for l1 in range(1, 11):
matcher[f't... | ha_xiaomi_home |
python | """Platform for cover integration."""
from typing import Any
from boschshcpy import SHCShutterControl
from homeassistant.components.cover import (
ATTR_POSITION,
CoverDeviceClass,
CoverEntity,
CoverEntityFeature,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platfor... | """Tests for Comelit SimpleHome cover platform."""
from unittest.mock import AsyncMock, patch
from aiocomelit.api import ComelitSerialBridgeObject
from aiocomelit.const import COVER, WATT
from freezegun.api import FrozenDateTimeFactory
import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.c... | core |
python | """Support for Palazzetti buttons."""
from __future__ import annotations
from pypalazzetti.exceptions import CommunicationError
from homeassistant.components.button import ButtonEntity
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.enti... | """Test DoorBird buttons."""
from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS
from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN
from homeassistant.core import HomeAssistant
from .conftest import DoorbirdMockerType
async def test_relay_button(
hass: HomeAssistant,
... | core |
python | """Init file for Home Assistant."""
| """Test init of LCN integration."""
from unittest.mock import Mock, patch
from pypck.connection import (
PchkAuthenticationError,
PchkConnectionFailedError,
PchkConnectionRefusedError,
PchkLcnNotConnectedError,
PchkLicenseError,
)
from pypck.lcn_defs import LcnEvent
import pytest
from syrupy.asser... | core |
python | """Prompt Mixin."""
from abc import ABC, abstractmethod
from collections import defaultdict
from copy import deepcopy
from typing import Dict, Union
from llama_index.core.prompts.base import BasePromptTemplate
HasPromptType = Union["PromptMixin", BasePromptTemplate]
PromptDictType = Dict[str, BasePromptTemplate]
Pro... | """Test prompt mixin."""
from llama_index.core.prompts.base import PromptTemplate
from llama_index.core.prompts.mixin import (
PromptDictType,
PromptMixin,
PromptMixinType,
)
class MockObject2(PromptMixin):
def __init__(self) -> None:
self._prompt_dict_2 = {
"abc": PromptTemplate(... | llama_index |
python | import sentry_sdk
from rest_framework.exceptions import ParseError
from rest_framework.request import Request
from rest_framework.response import Response
from sentry import options
from sentry.api.api_publish_status import ApiPublishStatus
from sentry.api.base import ReleaseAnalyticsMixin, region_silo_endpoint
from s... | import unittest
from datetime import UTC, datetime
import pytest
from django.urls import reverse
from sentry.api.serializers.rest_framework.release import ReleaseSerializer
from sentry.constants import MAX_VERSION_LENGTH
from sentry.models.activity import Activity
from sentry.models.files.file import File
from sentry... | sentry |
python | # Copyright (c) Microsoft. All rights reserved.
import uuid
from dapr.actor import ActorId, ActorProxy
from semantic_kernel.processes.dapr_runtime.actors.process_actor import ProcessActor
from semantic_kernel.processes.dapr_runtime.dapr_process_info import DaprProcessInfo
from semantic_kernel.processes.dapr_runtime.... | # Copyright (c) Microsoft. All rights reserved.
import uuid
from unittest.mock import AsyncMock, patch
import pytest
from semantic_kernel.processes.dapr_runtime.dapr_kernel_process_context import DaprKernelProcessContext
from semantic_kernel.processes.dapr_runtime.dapr_process_info import DaprProcessInfo
from semant... | semantic-kernel |
python | from __future__ import annotations
import mimetypes
import re
import warnings
from urllib.parse import quote
from mitmproxy.net.http import headers
def encode_multipart(content_type: str, parts: list[tuple[bytes, bytes]]) -> bytes:
if content_type:
ct = headers.parse_content_type(content_type)
i... | import pytest
from mitmproxy.net.http import multipart
def test_decode():
boundary = "somefancyboundary"
content = (
"--{0}\n"
'Content-Disposition: form-data; name="field1"\n\n'
"value1\n"
"--{0}\n"
'Content-Disposition: form-data; name="field2"\n\n'
"value2\n... | mitmproxy |
python | from types import SimpleNamespace
from typing import TYPE_CHECKING, Any, Generic, Protocol, TypeVar, overload
from aiosignal import Signal
from multidict import CIMultiDict
from yarl import URL
from .client_reqrep import ClientResponse
from .helpers import frozen_dataclass_decorator
if TYPE_CHECKING:
from .clien... | import sys
from types import SimpleNamespace
from typing import Any
from unittest import mock
from unittest.mock import Mock
import pytest
from aiosignal import Signal
from aiohttp import ClientSession
from aiohttp.tracing import (
Trace,
TraceConfig,
TraceConnectionCreateEndParams,
TraceConnectionCre... | aiohttp |
python | """Support for Palazzetti sensors."""
from dataclasses import dataclass
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorEntityDescription,
SensorStateClass,
)
from homeassistant.const import UnitOfLength, UnitOfMass, UnitOfTemperature
from homeassistant.core import... | """The tests for the Modbus sensor component."""
import math
import struct
import pytest
from homeassistant.components.homeassistant import SERVICE_UPDATE_ENTITY
from homeassistant.components.modbus.const import (
CALL_TYPE_REGISTER_HOLDING,
CALL_TYPE_REGISTER_INPUT,
CONF_DATA_TYPE,
CONF_DEVICE_ADDRE... | core |
python | """HMAC-based One-time Password auth module.
Sending HOTP through notify service
"""
from __future__ import annotations
import asyncio
import logging
from typing import Any, cast
import attr
import voluptuous as vol
from homeassistant.const import CONF_EXCLUDE, CONF_INCLUDE
from homeassistant.core import HomeAssis... | """The test for the Facebook notify module."""
from http import HTTPStatus
import pytest
import requests_mock
from homeassistant.components.facebook import notify as fb
from homeassistant.core import HomeAssistant
@pytest.fixture
def facebook() -> fb.FacebookNotificationService:
"""Fixture for facebook."""
... | core |
python | from localstack.services.cloudformation.resource_provider import (
CloudFormationResourceProviderPlugin,
ResourceProvider,
)
class EC2SecurityGroupProviderPlugin(CloudFormationResourceProviderPlugin):
name = "AWS::EC2::SecurityGroup"
def __init__(self):
self.factory: type[ResourceProvider] | ... | import pytest
import requests
from localstack import config
from localstack.aws.handlers import cors as cors_handler
from localstack.aws.handlers.cors import _get_allowed_cors_origins
from localstack.testing.config import TEST_AWS_ACCESS_KEY_ID, TEST_AWS_REGION_NAME
from localstack.utils.aws.request_context import moc... | localstack |
python | """Helper to test significant Cover state changes."""
from __future__ import annotations
from typing import Any
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.significant_change import (
check_absolute_change,
check_valid_float,
)
from . import ATTR_CURRENT_POSITION, ATTR_... | """Test the Media Player significant change platform."""
import pytest
from homeassistant.components.media_player import (
ATTR_APP_ID,
ATTR_APP_NAME,
ATTR_ENTITY_PICTURE_LOCAL,
ATTR_GROUP_MEMBERS,
ATTR_INPUT_SOURCE,
ATTR_MEDIA_ALBUM_ARTIST,
ATTR_MEDIA_ALBUM_NAME,
ATTR_MEDIA_ARTIST,
... | core |
python | # -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._createable_api_resource import CreateableAPIResource
from stripe._list_object import ListObject
from stripe._listable_api_resource import ListableAPIResource
from typing import ClassVar, Optional, cast
from typing_extensions import Literal, Unp... | import tempfile
import pytest
import stripe
from stripe._multipart_data_generator import MultipartDataGenerator
from stripe._util import convert_to_stripe_object
TEST_RESOURCE_ID = "file_123"
class TestFile(object):
@pytest.fixture(scope="function")
def setup_upload_api_base(self):
stripe.upload_a... | stripe-python |
python | from __future__ import annotations
from pip._vendor.packaging.utils import canonicalize_name
from pip._internal.exceptions import CommandError
class FormatControl:
"""Helper for managing formats from which a package can be installed."""
__slots__ = ["no_binary", "only_binary"]
def __init__(
se... | from optparse import Values
import pytest
from pip._internal.cli import cmdoptions
from pip._internal.cli.base_command import Command
from pip._internal.cli.status_codes import SUCCESS
from pip._internal.models.format_control import FormatControl
class SimpleCommand(Command):
def __init__(self) -> None:
... | pip |
python | """Automatically generated file.
To update, run python3 -m script.hassfest
"""
FLOWS = {
"helper": [
"derivative",
"filter",
"generic_hygrostat",
"generic_thermostat",
"group",
"history_stats",
"integration",
"min_max",
"mold_indicator",
... | """Test the Prosegur Alarm config flow."""
from unittest.mock import patch
import pytest
from homeassistant import config_entries
from homeassistant.components.prosegur.config_flow import CannotConnect, InvalidAuth
from homeassistant.components.prosegur.const import DOMAIN
from homeassistant.core import HomeAssistan... | core |
python | """Automatically generated file.
To update, run python3 -m script.hassfest
"""
FLOWS = {
"helper": [
"derivative",
"filter",
"generic_hygrostat",
"generic_thermostat",
"group",
"history_stats",
"integration",
"min_max",
"mold_indicator",
... | """Test the WiZ Platform config flow."""
from unittest.mock import AsyncMock, patch
import pytest
from pywizlight.exceptions import WizLightConnectionError, WizLightTimeOutError
from homeassistant import config_entries
from homeassistant.components.wiz.config_flow import CONF_DEVICE
from homeassistant.components.wiz... | core |
python | """Automatically generated file.
To update, run python3 -m script.hassfest
"""
FLOWS = {
"helper": [
"derivative",
"filter",
"generic_hygrostat",
"generic_thermostat",
"group",
"history_stats",
"integration",
"min_max",
"mold_indicator",
... | """Test the SensorPush config flow."""
from unittest.mock import patch
from homeassistant import config_entries
from homeassistant.components.sensorpush.const import DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResultType
from . import HTPWX_SERVICE_INFO, HTW_SERV... | core |
python | import functools
import inspect
import operator
import types
import warnings
import numpy as np
from numpy._core import overrides
from numpy._core._multiarray_umath import _array_converter
from numpy._core.multiarray import add_docstring
from . import numeric as _nx
from .numeric import asanyarray, nan, ndim, result_... | import platform
import sys
import pytest
import numpy as np
from numpy import (
arange,
array,
dtype,
errstate,
geomspace,
isnan,
linspace,
logspace,
ndarray,
nextafter,
sqrt,
stack,
)
from numpy._core import sctypes
from numpy._core.function_base import add_newdoc
from... | numpy |
python | """Advanced timeout handling.
Set of helper classes to handle timeouts of tasks with advanced options
like zones and freezing of timeouts.
"""
from __future__ import annotations
import asyncio
import enum
from types import TracebackType
from typing import Any, Self
from .async_ import run_callback_threadsafe
ZONE_... | """Test ESPHome times."""
from unittest.mock import call
from aioesphomeapi import APIClient, TimeInfo, TimeState
from homeassistant.components.time import (
ATTR_TIME,
DOMAIN as TIME_DOMAIN,
SERVICE_SET_VALUE,
)
from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN
from homeassistant.core import... | core |
python | """Automatically generated file.
To update, run python3 -m script.hassfest
"""
FLOWS = {
"helper": [
"derivative",
"filter",
"generic_hygrostat",
"generic_thermostat",
"group",
"history_stats",
"integration",
"min_max",
"mold_indicator",
... | """Test the Duke Energy config flow."""
from unittest.mock import AsyncMock, Mock
from aiohttp import ClientError, ClientResponseError
import pytest
from homeassistant import config_entries
from homeassistant.components.duke_energy.const import DOMAIN
from homeassistant.components.recorder import Recorder
from homea... | core |
python | """Reproduce an Cover state."""
from __future__ import annotations
import asyncio
from collections.abc import Coroutine, Iterable
from functools import partial
import logging
from typing import Any, Final
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_SUPPORTED_FEATURES,
SERVICE_CLOSE_COVER,
... | """Test reproduce state for Counter."""
import pytest
from homeassistant.core import HomeAssistant, State
from homeassistant.helpers.state import async_reproduce_state
from tests.common import async_mock_service
async def test_reproducing_states(
hass: HomeAssistant, caplog: pytest.LogCaptureFixture
) -> None:... | core |
python | import logging
from collections.abc import Mapping
from datetime import datetime, timezone
from typing import Any, cast
import orjson
from arroyo.backends.kafka import KafkaPayload
from arroyo.processing.strategies import (
CommitOffsets,
ProcessingStrategy,
ProcessingStrategyFactory,
)
from arroyo.types i... | from datetime import datetime
from time import sleep as real_sleep # Import before monkeypatch
from unittest import mock
import orjson
import pytest
from arroyo.backends.kafka import KafkaPayload
from arroyo.dlq import InvalidMessage
from arroyo.types import BrokerValue, Message, Partition, Topic
from sentry.spans.c... | sentry |
python | from collections import defaultdict
import graphene
from django.core.exceptions import ValidationError
from .....core.tracing import traced_atomic_transaction
from .....discount import DiscountValueType, models
from .....discount.error_codes import DiscountErrorCode
from .....permission.enums import DiscountPermissio... | import json
from unittest.mock import patch
import graphene
from django.utils.functional import SimpleLazyObject
from freezegun import freeze_time
from .....core.utils.json_serializer import CustomJsonEncoder
from .....discount import DiscountValueType
from .....discount.error_codes import DiscountErrorCode
from ....... | saleor |
python | import multiprocessing
import os
import shutil
import sqlite3
import sys
from pathlib import Path
from django.db import NotSupportedError
from django.db.backends.base.creation import BaseDatabaseCreation
class DatabaseCreation(BaseDatabaseCreation):
@staticmethod
def is_in_memory_db(database_name):
r... | import copy
import multiprocessing
import unittest
from unittest import mock
from django.db import DEFAULT_DB_ALIAS, NotSupportedError, connection, connections
from django.test import SimpleTestCase
@unittest.skipUnless(connection.vendor == "sqlite", "SQLite tests")
class TestDbSignatureTests(SimpleTestCase):
de... | django |
python | """Support for Palazzetti sensors."""
from dataclasses import dataclass
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorEntityDescription,
SensorStateClass,
)
from homeassistant.const import UnitOfLength, UnitOfMass, UnitOfTemperature
from homeassistant.core import... | """Tests for Fritz!Tools sensor platform."""
from __future__ import annotations
from datetime import UTC, datetime, timedelta
from unittest.mock import patch
from fritzconnection.core.exceptions import FritzConnectionException
import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.component... | core |
python | import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
class BaseMissingTests:
def test_isna(self, data_missing):
expected = np.array([True, False])
result = pd.isna(data_missing)
tm.assert_numpy_array_equal(result, expected)
result = pd.Series(data_mi... | import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
)
import pandas._testing as tm
@pytest.mark.parametrize("func", ["ffill", "bfill"])
def test_groupby_column_index_name_lost_fill_funcs(func):
# GH: 29764 groupby loses index sometimes
df = DataFrame(
[... | pandas |
python | import logging
from base64 import b64encode
from typing import Any
import petname
from django.http import HttpResponse
from rest_framework import serializers, status
from rest_framework.fields import SkipField
from rest_framework.request import Request
from rest_framework.response import Response
from sentry import r... | from unittest import mock
from django.core import mail
from django.db import router
from django.db.models import F
from django.urls import reverse
from sentry import audit_log
from sentry.auth.authenticators.sms import SmsInterface
from sentry.auth.authenticators.totp import TotpInterface
from sentry.models.auditloge... | sentry |
python | r"""
Renderer that will decrypt NACL ciphers
Any key in the SLS file can be an NACL cipher, and this renderer will decrypt it
before passing it off to Salt. This allows you to safely store secrets in
source control, in such a way that only your Salt master can decrypt them and
distribute them only to the minions that ... | import pytest
import salt.renderers.nacl as nacl
from tests.support.mock import MagicMock, patch
@pytest.fixture
def configure_loader_modules():
return {nacl: {}}
def test__decrypt_object():
"""
test _decrypt_object
"""
secret = "Use more salt."
crypted = "NACL[MRN3cc+fmdxyQbz6WMF+jq1hKdU5X... | salt |
python | import logging
from datetime import datetime, timedelta, timezone
from enum import Enum
from typing import Annotated, Any, Generic, Optional, TypeVar, Union
from prisma import Json
from prisma.enums import NotificationType
from prisma.models import NotificationEvent, UserNotificationBatch
from prisma.types import (
... | """Tests for notification data models."""
from datetime import datetime, timezone
import pytest
from pydantic import ValidationError
from backend.data.notifications import AgentApprovalData, AgentRejectionData
class TestAgentApprovalData:
"""Test cases for AgentApprovalData model."""
def test_valid_agent_... | AutoGPT |
python | """ Basic functions for manipulating 2d arrays
"""
import functools
import operator
from numpy._core import iinfo, overrides
from numpy._core._multiarray_umath import _array_converter
from numpy._core.numeric import (
arange,
asanyarray,
asarray,
diagonal,
empty,
greater_equal,
indices,
... | """Test functions for matrix module
"""
import pytest
import numpy as np
from numpy import (
add,
arange,
array,
diag,
eye,
fliplr,
flipud,
histogram2d,
mask_indices,
ones,
tri,
tril_indices,
tril_indices_from,
triu_indices,
triu_indices_from,
vander,
... | numpy |
python | from fastapi import FastAPI, File, UploadFile
from fastapi.responses import HTMLResponse
app = FastAPI()
@app.post("/files/")
async def create_files(
files: list[bytes] = File(description="Multiple files as bytes"),
):
return {"file_sizes": [len(file) for file in files]}
@app.post("/uploadfiles/")
async de... | import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from ...utils import needs_py39
@pytest.fixture(name="app")
def get_app():
from docs_src.websockets.tutorial003_py39 import app
return app
@pytest.fixture(name="html")
def get_html():
from docs_src.websockets.tutorial0... | fastapi |
python | from __future__ import annotations
import io as _io
from yaml.resolver import Resolver
from ansible.module_utils._internal._datatag import AnsibleTagHelper
from ansible.module_utils.common.yaml import HAS_LIBYAML
from ansible._internal._datatag import _tags
from ._constructor import AnsibleConstructor, AnsibleInstr... | # coding: utf-8
# (c) 2015, Toshio Kuratomi <tkuratomi@ansible.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your o... | ansible |
python | import re
from django.utils.translation import gettext_lazy as _
from rest_framework import exceptions
from rest_framework.compat import unicode_http_header
from rest_framework.reverse import _reverse
from rest_framework.settings import api_settings
from rest_framework.templatetags.rest_framework import replace_query... | import pytest
from django.test import override_settings
from django.urls import ResolverMatch, include, path, re_path
from rest_framework import serializers, status, versioning
from rest_framework.decorators import APIView
from rest_framework.relations import PKOnlyObject
from rest_framework.response import Response
f... | django-rest-framework |
python | """Creates a `LabelledSimpleDataset` version of the Symptom2Dataset."""
import os
import pandas as pd
from llama_index.core.llama_dataset.simple import (
LabelledSimpleDataExample,
LabelledSimpleDataset,
)
from llama_index.core.llama_dataset.base import CreatedBy, CreatedByType
from sklearn.model_selection imp... | """Test vector store indexes."""
import pickle
from typing import Any, List, cast
from llama_index.core.indices.loading import load_index_from_storage
from llama_index.core.indices.vector_store.base import VectorStoreIndex
from llama_index.core.schema import Document
from llama_index.core.storage.storage_context impo... | llama_index |
python | import argparse
import os
import sys
# important: this needs to be free of localstack imports
def set_and_remove_profile_from_sys_argv():
"""
Performs the following steps:
1. Use argparse to parse the command line arguments for the --profile flag.
All occurrences are removed from the sys.argv lis... | import os
import sys
from localstack.cli.profiles import set_and_remove_profile_from_sys_argv
def profile_test(monkeypatch, input_args, expected_profile, expected_argv):
monkeypatch.setattr(sys, "argv", input_args)
monkeypatch.setenv("CONFIG_PROFILE", "")
set_and_remove_profile_from_sys_argv()
assert... | localstack |
python | from typing import Union
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from typing_extensions import Annotated
app = FastAPI()
async def common_parameters(
q: Union[str, None] = None, skip: int = 0, limit: int = 100
):
return {"q": q, "skip": skip, "limit": limit}
@app.get... | import importlib
from fastapi.testclient import TestClient
from ...utils import needs_pydanticv2
def get_client() -> TestClient:
from docs_src.conditional_openapi import tutorial001
importlib.reload(tutorial001)
client = TestClient(tutorial001.app)
return client
@needs_pydanticv2
def test_disabl... | fastapi |
python | from enum import Enum
from typing import (
Any,
Awaitable,
Callable,
Coroutine,
Dict,
List,
Optional,
Sequence,
Type,
TypeVar,
Union,
)
from annotated_doc import Doc
from fastapi import routing
from fastapi.datastructures import Default, DefaultPlaceholder
from fastapi.excep... | import pytest
from dirty_equals import IsDict
from fastapi.testclient import TestClient
from .main import app
client = TestClient(app)
@pytest.mark.parametrize(
"path,expected_status,expected_response",
[
("/api_route", 200, {"message": "Hello World"}),
("/non_decorated_route", 200, {"messag... | fastapi |
python | """Switch platform for Growatt."""
from __future__ import annotations
from dataclasses import dataclass
import logging
from typing import Any
from growattServer import GrowattV1ApiError
from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
from homeassistant.const import EntityCategory
f... | """Tests for Vallox switch platform."""
import pytest
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON
from homeassistant.core import HomeAssistant
from .conftest import patch_set_values
from tests.common import Moc... | core |
python | """Init file for Home Assistant."""
| """Test Statistics component setup process."""
from __future__ import annotations
from unittest.mock import patch
import pytest
from homeassistant.components import statistics
from homeassistant.components.statistics import DOMAIN
from homeassistant.components.statistics.config_flow import StatisticsConfigFlowHandl... | core |
python | """
The Salt Key backend API and interface used by the CLI. The Key class can be
used to manage salt keys directly without interfacing with the CLI.
"""
import fnmatch
import itertools
import logging
import os
import sys
import salt.cache
import salt.client
import salt.crypt
import salt.exceptions
import salt.payload... | """
:codeauthor: Rupesh Tare <rupesht@saltstack.com>
Test cases for salt.modules.key
"""
import os.path
import pytest
import salt.modules.key as key
import salt.utils.crypt
from tests.support.mock import MagicMock, patch
@pytest.fixture
def configure_loader_modules():
return {key: {}}
def test_finge... | salt |
python | # Copyright (c) Recommenders contributors.
# Licensed under the MIT License.
import numpy as np
from sklearn.decomposition import PCA
def length_normalize(matrix):
"""Length normalize the matrix
Args:
matrix (np.ndarray): Input matrix that needs to be normalized
Returns:
Normalized matr... | # Copyright (c) Recommenders contributors.
# Licensed under the MIT License.
import collections
import pytest
import numpy as np
from scipy.sparse import csr_matrix
try:
from recommenders.models.geoimc.geoimc_data import DataPtr
from recommenders.models.geoimc.geoimc_predict import Inferer
from recommend... | recommenders |
python | from __future__ import annotations
import contextlib as _contextlib
import dataclasses
import typing as t
from ansible.module_utils._internal._datatag import AnsibleSingletonTagBase, _tag_dataclass_kwargs
from ansible.module_utils._internal._datatag._tags import Deprecated
from ansible._internal._datatag._tags import... | from __future__ import annotations
import collections.abc as c
import typing as t
import pytest
from ansible.module_utils._internal._datatag import (
AnsibleSerializable,
AnsibleTaggedObject,
)
# temporarily here to ensure this type is always "seen" in the known serializable types list
from ansible._interna... | ansible |
python | from __future__ import annotations
from typing import (
TYPE_CHECKING,
Any,
ClassVar,
)
import numpy as np
from pandas.util._decorators import set_module
from pandas.core.dtypes.base import register_extension_dtype
from pandas.core.dtypes.common import is_float_dtype
from pandas.core.arrays.numeric imp... | """
Tests that work on both the Python and C engines but do not have a
specific classification into the other test modules.
"""
from io import StringIO
import numpy as np
import pytest
from pandas import DataFrame
import pandas._testing as tm
pytestmark = pytest.mark.filterwarnings(
"ignore:Passing a BlockManag... | pandas |
python | """Send a reply from the proxy without sending the request to the remote server."""
from mitmproxy import http
def request(flow: http.HTTPFlow) -> None:
if flow.request.pretty_url == "http://example.com/path":
flow.response = http.Response.make(
200, # (optional) status code
b"He... | import argparse
import pytest
from mitmproxy import options
from mitmproxy.tools import cmdline
from mitmproxy.tools import main
class MockParser(argparse.ArgumentParser):
"""
argparse.ArgumentParser sys.exits() by default.
Make it more testable by throwing an exception instead.
"""
def error(s... | mitmproxy |
python | from sentry.integrations.services.integration import integration_service
from sentry.plugins.providers import IntegrationRepositoryProvider
from sentry.shared_integrations.exceptions import IntegrationError
class ExampleRepositoryProvider(IntegrationRepositoryProvider):
name = "Example"
repo_provider = "examp... | from unittest.mock import MagicMock, patch
from django.core import mail
from django.utils import timezone
from sentry.constants import ObjectStatus
from sentry.db.pending_deletion import build_pending_deletion_key
from sentry.deletions.tasks.scheduled import run_scheduled_deletions
from sentry.exceptions import Plugi... | sentry |
python | # ---------------------
# Flask App for Slack OAuth flow
# ---------------------
# pip3 install flask
from typing import Optional
from integration_tests.samples.token_rotation.util import (
parse_body,
extract_enterprise_id,
extract_user_id,
extract_team_id,
extract_is_enterprise_install,
extr... | import unittest
from slack_sdk.oauth.installation_store import Installation
from slack_sdk.oauth.installation_store.sqlite3 import SQLite3InstallationStore
class TestSQLite3(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_instance(self):
store = SQLit... | python-slack-sdk |
python | from slack_sdk.models.messages.message import Message # noqa
| import unittest
from slack_sdk.socket_mode.logger.messages import debug_redacted_message_string
class TestRequest(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_debug_redacted_message_string(self):
message = """{"envelope_id":"abc-123","payload":{"to... | python-slack-sdk |
python | """Automatically generated file.
To update, run python3 -m script.hassfest
"""
FLOWS = {
"helper": [
"derivative",
"filter",
"generic_hygrostat",
"generic_thermostat",
"group",
"history_stats",
"integration",
"min_max",
"mold_indicator",
... | """Test the Fressnapf Tracker config flow."""
from unittest.mock import AsyncMock, MagicMock
from fressnapftracker import (
FressnapfTrackerInvalidPhoneNumberError,
FressnapfTrackerInvalidTokenError,
SmsCodeResponse,
)
import pytest
from homeassistant import config_entries
from homeassistant.components.f... | core |
python | from __future__ import annotations
from collections import defaultdict
from collections.abc import Iterable, Mapping, Sequence
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from functools import cached_property
from typing import Any, TypeAlias
import sentry_sdk
from django.utils i... | from dataclasses import asdict
from datetime import datetime, timedelta
from unittest.mock import ANY, MagicMock, Mock, patch
import pytest
from django.utils import timezone
from sentry.grouping.grouptype import ErrorGroupType
from sentry.models.environment import Environment
from sentry.models.group import Group
fro... | sentry |
python | """Read only dictionary."""
from copy import deepcopy
from typing import Any, final
def _readonly(*args: Any, **kwargs: Any) -> Any:
"""Raise an exception when a read only dict is modified."""
raise RuntimeError("Cannot modify ReadOnlyDict")
@final # Final to allow direct checking of the type instead of u... | """Test read only dictionary."""
import copy
import json
import pytest
from homeassistant.util.read_only_dict import ReadOnlyDict
def test_read_only_dict() -> None:
"""Test read only dictionary."""
data = ReadOnlyDict({"hello": "world"})
with pytest.raises(RuntimeError):
data["hello"] = "unive... | core |
python | # Copyright (c) Microsoft. All rights reserved.
import logging
from collections.abc import Callable
from typing import TYPE_CHECKING, Any
from pybars import Compiler, PybarsError
from pydantic import PrivateAttr, field_validator
from semantic_kernel.exceptions import HandlebarsTemplateRenderException, HandlebarsTemp... | # Copyright (c) Microsoft. All rights reserved.
import pytest
from pytest import mark
from semantic_kernel.contents import AuthorRole
from semantic_kernel.contents.chat_history import ChatHistory
from semantic_kernel.contents.chat_message_content import ChatMessageContent
from semantic_kernel.contents.function_call_c... | semantic-kernel |
python | """Illustrates use of the :meth:`.AttributeEvents.init_scalar`
event, in conjunction with Core column defaults to provide
ORM objects that automatically produce the default value
when an un-set attribute is accessed.
"""
import datetime
from sqlalchemy import Column
from sqlalchemy import create_engine
from sqlalche... | import datetime
import itertools
import sqlalchemy as sa
from sqlalchemy import cast
from sqlalchemy import DateTime
from sqlalchemy import exc
from sqlalchemy import ForeignKey
from sqlalchemy import func
from sqlalchemy import Integer
from sqlalchemy import literal
from sqlalchemy import MetaData
from sqlalchemy imp... | sqlalchemy |
python | """Provide functionality to stream HLS."""
from __future__ import annotations
from http import HTTPStatus
from typing import TYPE_CHECKING, cast
from aiohttp import web
from homeassistant.core import HomeAssistant, callback
from .const import (
EXT_X_START_LL_HLS,
EXT_X_START_NON_LL_HLS,
FORMAT_CONTENT... | """The tests for hls streams."""
from datetime import timedelta
from http import HTTPStatus
from unittest.mock import patch
from urllib.parse import urlparse
import av
import pytest
from homeassistant.components.stream import Stream, create_stream
from homeassistant.components.stream.const import (
EXT_X_START_L... | core |
python | """Support led_brightness for Mi Air Humidifier."""
from __future__ import annotations
from dataclasses import dataclass, field
import logging
from typing import Any, NamedTuple
from miio import Device as MiioDevice
from miio.fan_common import LedBrightness as FanLedBrightness
from miio.integrations.airpurifier.dmak... | """The test for the sensibo select platform."""
from __future__ import annotations
from datetime import timedelta
from unittest.mock import MagicMock
from freezegun.api import FrozenDateTimeFactory
import pytest
from syrupy.assertion import SnapshotAssertion
from homeassistant.components.select import (
ATTR_OP... | core |
python | """
timedelta support tools
"""
from __future__ import annotations
from typing import (
TYPE_CHECKING,
Any,
overload,
)
import numpy as np
from pandas._libs import lib
from pandas._libs.tslibs import (
NaT,
NaTType,
)
from pandas._libs.tslibs.timedeltas import (
Timedelta,
disallow_ambig... | from datetime import timedelta
import numpy as np
import pytest
import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
DataFrame,
Series,
)
import pandas._testing as tm
from pandas.core.indexes.timedeltas import timedelta_range
def test_asfreq_bug():
df = DataFrame(data=[1, ... | pandas |
python | """Support for Xiaomi Mi WiFi Repeater 2."""
from __future__ import annotations
import logging
from miio import DeviceException, WifiRepeater
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN as DEVICE_TRACKER_DOMAIN,
PLATFORM_SCHEMA as DEVICE_TRACKER_PLATFORM_SCHEMA,
... | """Tests for the Device Utils."""
import pytest
import voluptuous as vol
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.helpers.device import (
async_device_info_to_link_from_device_id,
async_device_info_to_link_fr... | core |
python | """Init file for Home Assistant."""
| """Tests for the Tailscale integration."""
from unittest.mock import MagicMock
from tailscale import TailscaleAuthenticationError, TailscaleConnectionError
from homeassistant.components.tailscale.const import DOMAIN
from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntryState
from homeassistant.core impo... | core |
python | """Base object types."""
import os
import pickle
from abc import abstractmethod
from typing import Any, Dict, Generic, Optional, Sequence, TypeVar
from llama_index.core.schema import BaseNode, MetadataMode, TextNode
from llama_index.core.storage.storage_context import DEFAULT_PERSIST_DIR
from llama_index.core.utils i... | from typing import Any
import pytest
from llama_index.core.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
ObjectType,
RelatedNodeInfo,
)
@pytest.fixture()
def MyNode():
class MyNode(BaseNode):
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, ... | llama_index |
python | """
Module for gathering and managing bridging information
"""
import re
import sys
import salt.utils.path
__func_alias__ = {"list_": "list"}
# Other BSD-like derivatives that use ifconfig may work too
SUPPORTED_BSD_LIKE = ["FreeBSD", "NetBSD", "OpenBSD"]
def __virtual__():
"""
Confirm this module is sup... | """
:codeauthor: Rupesh Tare <rupesht@saltstack.com>
"""
import pytest
import salt.modules.bridge as bridge
from tests.support.mock import MagicMock, patch
@pytest.fixture
def configure_loader_modules():
return {bridge: {}}
def test_show():
"""
Test for Returns bridges interfaces
along with en... | salt |
python | import graphene
from django.core.exceptions import ValidationError
from ....checkout import AddressType, models
from ....checkout.checkout_cleaner import (
clean_checkout_shipping,
validate_checkout_email,
)
from ....checkout.complete_checkout import complete_checkout
from ....checkout.error_codes import Check... | import datetime
from decimal import Decimal
from unittest import mock
import pytest
from django.core.exceptions import ValidationError
from django.test import override_settings
from django.utils import timezone
from prices import TaxedMoney
from ...account import CustomerEvents
from ...account.models import CustomerE... | saleor |
python | """
Management of the Salt scheduler
==============================================
.. code-block:: yaml
job3:
schedule.present:
- function: test.ping
- seconds: 3600
- splay: 10
This will schedule the command: test.ping every 3600 seconds
(every hour) splaying the time between 0 an... | """
:codeauthor: Jayesh Kariya <jayeshk@saltstack.com>
"""
import datetime
import logging
import pytest
import salt.modules.schedule as schedule
import salt.utils.odict
from salt.utils.event import SaltEvent
from salt.utils.odict import OrderedDict
from tests.support.mock import MagicMock, call, mock_open, patch... | salt |
python | """Helper for WebRTC support."""
from __future__ import annotations
from abc import ABC, abstractmethod
import asyncio
from collections.abc import Awaitable, Callable
from dataclasses import asdict, dataclass, field
from functools import cache, partial, wraps
import logging
from typing import TYPE_CHECKING, Any
from... | """Test camera WebRTC."""
from collections.abc import AsyncGenerator
from typing import Any
from unittest.mock import AsyncMock, Mock, patch
import pytest
from webrtc_models import RTCIceCandidate, RTCIceCandidateInit, RTCIceServer
from homeassistant.components.camera import (
Camera,
CameraWebRTCProvider,
... | core |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.