text stringlengths 213 32.3k |
|---|
from flask import Flask, jsonify, request
from flasgger import Swagger, LazyString, LazyJSONEncoder
app = Flask(__name__)
# Set the LAzyString JSON Encoder
app.json_encoder = LazyJSONEncoder
app.config['SWAGGER'] = {
'uiversion': 2
}
template = dict(
info={
'title': LazyString(lambda: 'Lazy Title'... |
from pyiqvia import Client
from pyiqvia.errors import InvalidZipError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.helpers import aiohttp_client
from .const import CONF_ZIP_CODE, DOMAIN # pylint:disable=unused-import
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN... |
import amqp
from kombu.utils.amq_manager import get_manager
from kombu.utils.text import version_string_as_tuple
from . import base
from .base import to_rabbitmq_queue_arguments
DEFAULT_PORT = 5672
DEFAULT_SSL_PORT = 5671
class Message(base.Message):
"""AMQP Message."""
def __init__(self, msg, channel=No... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import re
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import sample
from perfkitbenchmarker.linux_packages import cuda_toolkit
from perfkitbenchmarker.linux_packages im... |
import json
import os
import threading
import unittest
from http.server import BaseHTTPRequestHandler, HTTPServer
from test.support import EnvironmentVarGuard
from urllib.parse import urlparse
from kaggle_web_client import (KaggleWebClient,
_KAGGLE_URL_BASE_ENV_VAR_NAME,
... |
import voluptuous as vol
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import DEVICE_DEFAULT_NAME
import homeassistant.helpers.config_validation as cv
from . import CONF_PORTS, DATA_GC100
_SENSORS_SCHEMA = vol.Schema({cv.string: cv.string})
PLATFORM... |
import logging
import pytest
import yaml
from PyQt5.QtCore import QUrl, QPoint, QByteArray, QObject
QWebView = pytest.importorskip('PyQt5.QtWebKitWidgets').QWebView
from qutebrowser.misc import sessions
from qutebrowser.misc.sessions import TabHistoryItem as Item
from qutebrowser.utils import objreg, qtutils
from qu... |
import os
from kaggle_web_client import KaggleWebClient
_KAGGLE_TPU_NAME_ENV_VAR_NAME = 'TPU_NAME'
class KaggleDatasets:
GET_GCS_PATH_ENDPOINT = '/requests/CopyDatasetVersionToKnownGcsBucketRequest'
TIMEOUT_SECS = 600
# Integration types for GCS
AUTO_ML = 1
TPU = 2
def __init__(self):
... |
from .unit import Unit
from .digit_removal import DigitRemoval
from .fixed_length import FixedLength
from .frequency_filter import FrequencyFilter
from .lemmatization import Lemmatization
from .lowercase import Lowercase
from .matching_histogram import MatchingHistogram
from .ngram_letter import NgramLetter
from .punc... |
from django.contrib import admin
from django.urls import NoReverseMatch
from django.utils.html import format_html
from django.utils.translation import gettext_lazy as _
from zinnia.admin.forms import CategoryAdminForm
class CategoryAdmin(admin.ModelAdmin):
"""
Admin for Category model.
"""
form = Ca... |
from behave import then
@then('it should have a return code of "{code:d}"')
def see_expected_return_code(context, code):
print(context.output)
print(context.return_code)
print()
assert context.return_code == code
@then('the output should contain "{output_string}"')
def output_contains(context, outp... |
from datetime import timedelta
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.light import DOMAIN
from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_comp... |
from datetime import timedelta
import logging
from async_timeout import timeout
from canary.api import Api
from requests import ConnectTimeout, HTTPError
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const im... |
import pytest
import matchzoo as mz
@pytest.mark.cron
def test_load_data():
train_data = mz.datasets.wiki_qa.load_data('train', task='ranking')
assert len(train_data) == 20360
train_data, _ = mz.datasets.wiki_qa.load_data('train',
task='classification',
... |
import datetime
import logging
import voluptuous as vol
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
ATTR_RGB_COLOR,
ATTR_TRANSITION,
ATTR_WHITE_VALUE,
ATTR_XY_COLOR,
DOMAIN as LIGHT_DOMAIN,
VALID_TRANSITION,
is_on,
)
from homeassistant.components... |
import pytest
import homeassistant.components.remote as remote
from homeassistant.components.remote import ATTR_COMMAND
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.setup import async_setup_component
ENTITY_ID = "re... |
import sys
import pathlib
import pytest
from scripts.dev import check_coverage
pytest_plugins = 'pytester'
pytestmark = [pytest.mark.linux, pytest.mark.not_frozen]
class CovtestHelper:
"""Helper object for covtest fixture.
Attributes:
_testdir: The testdir fixture from pytest.
_monkeypa... |
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA
from homeassistant.const import DEVICE_DEFAULT_NAME
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import ToggleEntity
from . import CONF_PORTS, DATA_GC100
_SWITCH_SCHEMA = vol.Schema({cv.str... |
import logging
import voluptuous as vol
from homeassistant.components.alarm_control_panel import (
ENTITY_ID_FORMAT,
FORMAT_NUMBER,
PLATFORM_SCHEMA,
AlarmControlPanelEntity,
)
from homeassistant.components.alarm_control_panel.const import (
SUPPORT_ALARM_ARM_AWAY,
SUPPORT_ALARM_ARM_HOME,
... |
from os import path
import sphinx
__version__ = '0.5.0'
__version_full__ = __version__
def get_html_theme_path():
"""Return list of HTML theme paths."""
cur_dir = path.abspath(path.dirname(path.dirname(__file__)))
return cur_dir
# See http://www.sphinx-doc.org/en/stable/theming.html#distribute-your-... |
import boto3
from moto import mock_sts, mock_s3
@mock_sts()
@mock_s3()
def test_put_delete_s3_object(app):
from lemur.plugins.lemur_aws.s3 import put, delete, get
bucket = "public-bucket"
region = "us-east-1"
account = "123456789012"
path = "some-path/foo"
data = "dummy data"
s3_client ... |
import logging
from pyhap.const import (
CATEGORY_GARAGE_DOOR_OPENER,
CATEGORY_WINDOW,
CATEGORY_WINDOW_COVERING,
)
from homeassistant.components.cover import (
ATTR_CURRENT_POSITION,
ATTR_CURRENT_TILT_POSITION,
ATTR_POSITION,
ATTR_TILT_POSITION,
DOMAIN,
SUPPORT_SET_TILT_POSITION,
... |
import os
import imp
try:
from StringIO import StringIO
except ImportError: # python 3
from io import StringIO
import sys
import tempfile
import unittest
from unittest import skipUnless
from lxml.builder import ElementMaker
from lxml.etree import Element, ElementTree, ParserError
from lxml... |
from absl import flags
from perfkitbenchmarker import errors
flags.DEFINE_enum('tcmalloc_version', 'off',
['off', 'gperftools', 'experimental'],
'the tcmalloc version to be preloaded')
flags.DEFINE_string(
'tcmalloc_experimental_url', '',
'the GCS URL for downloading the tc... |
from tabulate import tabulate
from flask_script import Manager
from lemur.reporting.service import fqdns, expiring_certificates
manager = Manager(usage="Reporting related tasks.")
@manager.option(
"-v",
"--validity",
dest="validity",
choices=["all", "expired", "valid"],
default="all",
help=... |
from datetime import timedelta
import logging
from typing import List
from greeclimate.device import (
FanSpeed,
HorizontalSwing,
Mode,
TemperatureUnits,
VerticalSwing,
)
from greeclimate.exceptions import DeviceTimeoutError
from homeassistant.components.climate import ClimateEntity
from homeassi... |
import argparse
import pathlib
import sys
import os
import os.path
import shutil
import venv
import subprocess
from typing import List, Optional, Tuple
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir))
from scripts import utils, link_pyqt
REPO_ROOT = pathlib.Path(__file__).parent.parent
def p... |
import logging
import os
logging.basicConfig()
logger = logging.getLogger("kalliope")
class FileManager:
"""
Class used to manage Files
"""
def __init__(self):
pass
@staticmethod
def create_directory(cache_path):
"""
Create a directory at the provided `cache_path`
... |
from datetime import datetime, timedelta
import logging
import time
from pytz import timezone
import requests
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_API_KEY,
CONF_HOST,
CONF_MONITORED_CONDITIONS,
CONF_PORT,
CONF_... |
import os
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
def test_hostname(host):
assert 'instance' == host.check_output('hostname -s')
def test_etc_molecule_directory(host):
f = host.file('... |
from scattertext.TermDocMatrix import TermDocMatrix
from scattertext.indexstore import IndexStore, IndexStoreFromList, IndexStoreFromDict
from scipy.sparse import csr_matrix
class DimensionMismatchException(Exception):
pass
class TermDocMatrixFromScikit(object):
'''
A factory class for building a TermDocMatrix... |
import unittest
import openrazer_daemon.device
DEVICE1_SERIAL = 'XX000000'
DEVICE1_ID = '0000:0000:0000.0000'
DEVICE2_SERIAL = 'XX000001'
DEVICE2_ID = '0000:0000:0000.0001'
class DummyDBusObject(object):
def __init__(self):
self.notify_msg = None
self.parent = None
def notify(self, msg):
... |
import pytest
import pyvera as pv
from requests.exceptions import RequestException
from homeassistant.components.vera import (
CONF_CONTROLLER,
CONF_EXCLUDE,
CONF_LIGHTS,
DOMAIN,
)
from homeassistant.config_entries import ENTRY_STATE_NOT_LOADED
from homeassistant.core import HomeAssistant
from .commo... |
import os
import pytest
import numpy as np
from mne.viz.backends.tests._utils import (skips_if_not_mayavi,
skips_if_not_pyvista)
from mne.viz.backends._utils import ALLOWED_QUIVER_MODES
@pytest.fixture
def backend_mocker():
"""Help to test set up 3d backend."""
fr... |
import diamond.collector
import telnetlib
import time
class MogilefsCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(MogilefsCollector, self).get_default_config_help()
config_help.update({
'path': 'Metric path',
})
return ... |
from typing import Optional
from homeassistant.components.device_tracker import SOURCE_TYPE_GPS
from homeassistant.components.device_tracker.config_entry import TrackerEntity
from . import DOMAIN as TESLA_DOMAIN, TeslaDevice
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the Tes... |
from __future__ import unicode_literals
import os
from lib.fun.fun import cool
from core.CONF import build_conf_dic
from core.PATTERN import build_pattern_dic
from lib.data.data import paths, pyoptions
def plug_parser():
if pyoptions.args_plug[0] not in pyoptions.plug_range:
exit("[!] Choose plugin from... |
from datetime import datetime as dt
import pytz
from mock import patch
from pandas.util.testing import assert_frame_equal
from arctic.date._mktz import mktz
from tests.util import read_str_as_pandas, multi_index_df_from_arrs
pytest_plugins = ['arctic.fixtures.arctic']
ts1 = read_str_as_pandas(""" sample... |
from homeassistant.components.abode import ATTR_DEVICE_ID
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
SERVICE_LOCK,
SERVICE_UNLOCK,
STATE_LOCKED,
)
from .common import setup_platform
from tests.async_mock im... |
import voluptuous as vol
from homeassistant.components.cover import (
ATTR_POSITION,
DEVICE_CLASSES_SCHEMA,
PLATFORM_SCHEMA,
SUPPORT_CLOSE,
SUPPORT_OPEN,
SUPPORT_SET_POSITION,
SUPPORT_STOP,
CoverEntity,
)
from homeassistant.const import CONF_DEVICE_CLASS, CONF_NAME
import homeassistant... |
import unittest
import mock
from docker_registry.lib.index import db
class TestVersion(unittest.TestCase):
def setUp(self):
self.version = db.Version()
def test_repr(self):
self.assertEqual(type(repr(self.version)), str)
class TestRepository(unittest.TestCase):
def setUp(self):
... |
revision = "1db4f82bc780"
down_revision = "3adfdd6598df"
from alembic import op
from flask import current_app
from logging import Formatter, FileHandler, getLogger
log = getLogger(__name__)
handler = FileHandler(current_app.config.get("LOG_UPGRADE_FILE", "db_upgrade.log"))
handler.setFormatter(
Formatter(
... |
import pytest
from homeassistant.components.homekit.const import ATTR_VALUE
from homeassistant.components.homekit.type_locks import Lock
from homeassistant.components.lock import DOMAIN
from homeassistant.const import (
ATTR_CODE,
ATTR_ENTITY_ID,
STATE_LOCKED,
STATE_UNKNOWN,
STATE_UNLOCKED,
)
fro... |
from homeassistant.components.media_player import DOMAIN as MP_DOMAIN
from .const import DOMAIN, HASS_DATA_REMOVE_LISTENERS_KEY, HASS_DATA_UPDATER_KEY
async def async_setup(hass, config):
"""Set up the forked-daapd component."""
return True
async def async_setup_entry(hass, entry):
"""Set up forked-da... |
import asyncio
from types import ModuleType
from typing import Any, Callable, Dict, Optional
import attr
from homeassistant.const import ATTR_LATITUDE, ATTR_LONGITUDE
from homeassistant.core import callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import config_per_platform
... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import Mock
from mock import patch
from diamond.collector import Collector
from nfacct import NetfilterAccountingCollector
##########################################################################
class Te... |
from os import environ
from sys import executable
from functools import partial
from riko.parsers import _make_content, entity2text
try:
from twisted.internet.defer import maybeDeferred, Deferred
except ImportError:
maybeDeferred = lambda *args: None
else:
from twisted.internet import defer
from twis... |
import logging
from typing import List, Optional
from pizone import Controller, Zone
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
FAN_AUTO,
FAN_HIGH,
FAN_LOW,
FAN_MEDIUM,
HVAC_MODE_COOL,
HVAC_MODE_DRY,
HVAC_MODE_FAN_ONLY,
... |
from uuid import uuid4
from homeassistant.components.alexa import config, smart_home
from homeassistant.core import Context
from tests.common import async_mock_service
TEST_URL = "https://api.amazonalexa.com/v3/events"
TEST_TOKEN_URL = "https://api.amazon.com/auth/o2/token"
TEST_LOCALE = "en-US"
class MockConfig(... |
import asyncio
import logging
from types import MappingProxyType
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import Context, State
from homeassistant.helpers.typ... |
import openzwavemqtt.const as const_ozw
from openzwavemqtt.const import CommandClass, ValueGenre, ValueIndex, ValueType
from . import const
DISCOVERY_SCHEMAS = (
{ # Binary sensors
const.DISC_COMPONENT: "binary_sensor",
const.DISC_VALUES: {
const.DISC_PRIMARY: {
const... |
from requests import ConnectTimeout
from homeassistant.components.camera.const import DOMAIN as CAMERA_DOMAIN
from homeassistant.components.canary.const import CONF_FFMPEG_ARGUMENTS, DOMAIN
from homeassistant.config_entries import (
ENTRY_STATE_LOADED,
ENTRY_STATE_NOT_LOADED,
ENTRY_STATE_SETUP_RETRY,
)
fr... |
import json
import threading
from absl import flags
from perfkitbenchmarker import network
from perfkitbenchmarker import providers
from perfkitbenchmarker import resource
from perfkitbenchmarker.providers.rackspace import util
FLAGS = flags.FLAGS
INGRESS = 'ingress'
EGRESS = 'egress'
SEC_GROUP_DIRECTIONS = frozens... |
from json import loads
from homeassistant.components.advantage_air.const import (
ADVANTAGE_AIR_STATE_CLOSE,
ADVANTAGE_AIR_STATE_OPEN,
)
from homeassistant.components.cover import (
ATTR_POSITION,
DEVICE_CLASS_DAMPER,
DOMAIN as COVER_DOMAIN,
SERVICE_CLOSE_COVER,
SERVICE_OPEN_COVER,
SER... |
import asyncio
import logging
from typing import Tuple
import discord
from redbot.core import Config, checks, commands
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils.chat_formatting import box
from .announcer import Announcer
from .converters import SelfRole
log = logging.getLogger("red.ad... |
import pytest
import pytest_httpbin
import vcr
from vcr.patch import force_reset
from assertions import assert_cassette_empty, assert_is_json
urllib3 = pytest.importorskip("urllib3")
@pytest.fixture(scope="module")
def verify_pool_mgr():
return urllib3.PoolManager(
cert_reqs="CERT_REQUIRED", ca_certs=py... |
import cerberus
import cerberus.errors
base_schema = {
'ansible': {
'type': 'dict',
'schema': {
'config_file': {
'type': 'string',
},
'playbook': {
'type': 'string',
},
'raw_env_vars': {
'ty... |
import voluptuous as vol
import homeassistant.helpers.config_validation as cv
CONF_ACCESS_KEY = "access_key"
CONF_APP_ID = "app_id"
DATA_TTN = "data_thethingsnetwork"
DOMAIN = "thethingsnetwork"
TTN_ACCESS_KEY = "ttn_access_key"
TTN_APP_ID = "ttn_app_id"
TTN_DATA_STORAGE_URL = (
"https://{app_id}.data.thething... |
import nltk
from .unit import Unit
class Stemming(Unit):
"""
Process unit for token stemming.
:param stemmer: stemmer to use, `porter` or `lancaster`.
"""
def __init__(self, stemmer='porter'):
"""Initialization."""
self.stemmer = stemmer
def transform(self, input_: list) -... |
import sys
from unittest.mock import Mock
import twisted.internet
from twisted.trial import unittest
from autobahn.twisted import choosereactor
class ChooseReactorTests(unittest.TestCase):
def patch_reactor(self, name, new_reactor):
"""
Patch ``name`` so that Twisted will grab a fake reactor i... |
import os
import sys
from coverage import env
from coverage.backward import litems, range # pylint: disable=redefined-builtin
from coverage.debug import short_stack
from coverage.disposition import FileDisposition
from coverage.misc import CoverageException, isolate_module
from coverage.pytracer import PyTracer
... |
import asyncio
import logging
import async_timeout
from pyflick.authentication import AuthException, SimpleFlickAuth
from pyflick.const import DEFAULT_CLIENT_ID, DEFAULT_CLIENT_SECRET
import voluptuous as vol
from homeassistant import config_entries, exceptions
from homeassistant.const import (
CONF_CLIENT_ID,
... |
import json
from django.conf import settings
import weblate
from weblate.machinery.base import (
MachineTranslation,
MachineTranslationError,
MissingConfiguration,
)
class ModernMTTranslation(MachineTranslation):
"""ModernMT machine translation support."""
name = "ModernMT"
max_score = 90
... |
from pynzbgetapi import NZBGetAPIException
from homeassistant.components.nzbget.const import DOMAIN
from homeassistant.config_entries import (
ENTRY_STATE_LOADED,
ENTRY_STATE_NOT_LOADED,
ENTRY_STATE_SETUP_RETRY,
)
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT
from homeassistant.setup imp... |
import pytest
def pytest_addoption(parser):
"""Add command-line flags for pytest."""
parser.addoption("--run-flaky", action="store_true", help="runs flaky tests")
parser.addoption(
"--run-network-tests",
action="store_true",
help="runs tests requiring a network connection",
)
... |
from ... import event
from . import Widget
class ImageWidget(Widget):
""" Display an image from a url.
The ``node`` of this widget is an
`<img> <https://developer.mozilla.org/docs/Web/HTML/Element/img>`_
wrapped in a `<div> <https://developer.mozilla.org/docs/Web/HTML/Element/div>`_
(the ``o... |
import asyncio
import logging
# pylint: disable=import-error
from haffmpeg.tools import IMAGE_JPEG, ImageFrame
from pyezviz.camera import EzvizCamera
from pyezviz.client import EzvizClient, PyEzvizError
import voluptuous as vol
from homeassistant.components.camera import PLATFORM_SCHEMA, SUPPORT_STREAM, Camera
from ... |
import logging
from pylutron_caseta.smartbridge import Smartbridge
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_HOST
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
from .const import CONF_CA_CERTS, CONF_C... |
import os
import pytest
from molecule import config
from molecule.driver import vagrant
@pytest.fixture
def _driver_section_data():
return {
'driver': {
'name': 'vagrant',
'provider': {
'name': 'virtualbox',
},
'options': {},
'... |
import logging
from contextlib import contextmanager
from lark import Lark, logger
from unittest import TestCase, main
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
@contextmanager
def capture_log():
stream = StringIO()
orig_handler = logger.handlers[0]
del logger... |
import chainer
import chainer.functions as F
import chainer.links as L
class SEBlock(chainer.Chain):
"""A squeeze-and-excitation block.
This block is part of squeeze-and-excitation networks. Channel-wise
multiplication weights are inferred from and applied to input feature map.
Please refer to `the... |
from scrapy.utils.misc import load_object
from scrapy.utils.serialize import ScrapyJSONEncoder
from twisted.internet.threads import deferToThread
from . import connection, defaults
default_serialize = ScrapyJSONEncoder().encode
class RedisPipeline(object):
"""Pushes serialized item into a redis list/queue
... |
import pytest
from unittest.mock import Mock
from kombu.asynchronous.aws.sqs.message import AsyncMessage
from kombu.asynchronous.aws.sqs.queue import AsyncQueue
from t.mocks import PromiseMock
from ..case import AWSCase
class test_AsyncQueue(AWSCase):
def setup(self):
self.conn = Mock(name='connecti... |
import logging
from freesms import FreeClient
import voluptuous as vol
from homeassistant.components.notify import PLATFORM_SCHEMA, BaseNotificationService
from homeassistant.const import (
CONF_ACCESS_TOKEN,
CONF_USERNAME,
HTTP_BAD_REQUEST,
HTTP_FORBIDDEN,
HTTP_INTERNAL_SERVER_ERROR,
)
import ho... |
from datetime import datetime as dt, timedelta
import pytest
from homeassistant.components import jewish_calendar
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from . import (
HDATE_DEFAULT_ALTITUDE,
alter_ti... |
from homeassistant.helpers.entity import Entity
from .const import DEFAULT_NAME, DOMAIN
class TadoZoneEntity(Entity):
"""Base implementation for tado device."""
def __init__(self, zone_name, device_info, device_id, zone_id):
"""Initialize an August device."""
super().__init__()
self... |
from collections import deque
import datetime
import email
import imaplib
import logging
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_DATE,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_USERNAME,
CONF_VALUE_TEMPLATE,
... |
import io
import logging
import os
import subprocess
from PIL import Image
import voluptuous as vol
from homeassistant.components.image_processing import (
CONF_ENTITY_ID,
CONF_NAME,
CONF_SOURCE,
PLATFORM_SCHEMA,
ImageProcessingEntity,
)
from homeassistant.core import split_entity_id
import homea... |
import discord
from redbot.core.utils.chat_formatting import box, humanize_number
from redbot.core import checks, bank, commands
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.bot import Red # Only used for type hints
_ = Translator("Bank", __file__)
def is_owner_if_bank_global():
"""
... |
import asyncio
import async_timeout
from pydeconz import DeconzSession, errors
from homeassistant.const import CONF_API_KEY, CONF_HOST, CONF_PORT
from homeassistant.core import callback
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import aiohttp_client
from homeassistant.helper... |
import logging
from unittest.mock import Mock, patch
from kombu.utils.debug import Logwrapped, setup_logging
class test_setup_logging:
def test_adds_handlers_sets_level(self):
with patch('kombu.utils.debug.get_logger') as get_logger:
logger = get_logger.return_value = Mock()
se... |
import os
import unittest
from perfkitbenchmarker import pkb
from perfkitbenchmarker import test_util
MOUNT_POINT = '/scratch'
@unittest.skipUnless('PERFKIT_INTEGRATION' in os.environ,
'PERFKIT_INTEGRATION not in environment')
class GcpScratchDiskIntegrationTest(unittest.TestCase):
"""Integr... |
import os
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
def test_hostname(host):
assert 'instance' == host.check_output('hostname -s')
def test_etc_molecule_directory(host):
f = host.file('... |
from homeassistant.components.switch import SwitchEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from .const import DOMAIN
from .devolo_device import DevoloDeviceEntity
async def async_setup_entry(
hass: HomeAssistantType, entry: ConfigEntr... |
import os
import pytest
from molecule import config
from molecule.driver import docker
@pytest.fixture
def _instance(config_instance):
return docker.Docker(config_instance)
def test_config_private_member(_instance):
assert isinstance(_instance._config, config.Config)
def test_testinfra_options_property... |
from homeassistant.const import (
CONF_DEVICE_CLASS,
CONF_ICON,
CONF_NAME,
CONF_TYPE,
CONF_UNIT_OF_MEASUREMENT,
)
from homeassistant.helpers.entity import Entity
from . import DOMAIN as DAIKIN_DOMAIN, DaikinApi
from .const import (
ATTR_COOL_ENERGY,
ATTR_HEAT_ENERGY,
ATTR_HUMIDITY,
... |
import numpy as np
import six
from chainercv.utils.testing.assertions.assert_is_image import assert_is_image
def assert_is_semantic_segmentation_dataset(dataset, n_class, n_example=None):
"""Checks if a dataset satisfies semantic segmentation dataset APIs.
This function checks if a given dataset satisfies ... |
from netort.process import execute
from ...common.interfaces import AbstractPlugin
class Plugin(AbstractPlugin):
"""
ShellExec plugin
allows executing shell scripts before/after test
"""
SECTION = 'shellexec'
def __init__(self, core, cfg, name):
AbstractPlugin.__init__(self, core, cf... |
import os
import pytest
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
@pytest.mark.skip(reason='Scenario tests not implemented yet')
def test_hostname(host):
assert 'instance' == host.check_outp... |
from pprint import pprint
from riko.bado import coroutine
from riko.collections import SyncPipe, AsyncPipe
p1_conf = {
'attrs': [
{
'value': 'http://www.caltrain.com/Fares/farechart.html',
'key': 'url'}]}
p2_conf = {
'rule': {
'field': 'url', 'match': {'subkey': 'url'}... |
import re # noqa: F401
import sys # noqa: F401
import nulltype # noqa: F401
from paasta_tools.paastaapi.model_utils import ( # noqa: F401
ApiTypeError,
ModelComposed,
ModelNormal,
ModelSimple,
cached_property,
change_keys_js_to_python,
convert_js_args_to_python_args,
date,
dat... |
import unittest
class TestImports(unittest.TestCase):
def test_import_boto3(self):
import boto3
print boto3
def test_import_numpy(self):
import numpy
print numpy
def test_import_osmium(self):
import osmium
print osmium
def test_import_requests(self)... |
import sys
import unittest
import numpy as np
from pandas import DataFrame
from mock import patch, call
from pgmpy.factors.discrete import State
from pgmpy.models import MarkovChain as MC
class TestMarkovChain(unittest.TestCase):
def setUp(self):
self.variables = ["intel", "diff", "grade"]
self... |
from typing import Dict
from urllib.parse import urlparse
import voluptuous as vol
from voluptuous.humanize import humanize_error
from .model import Integration
DOCUMENTATION_URL_SCHEMA = "https"
DOCUMENTATION_URL_HOST = "www.home-assistant.io"
DOCUMENTATION_URL_PATH_PREFIX = "/integrations/"
DOCUMENTATION_URL_EXCE... |
from django.http import HttpRequest, HttpResponseRedirect
from django.test import TestCase
from django.test.utils import override_settings
from weblate.accounts.middleware import RequireLoginMiddleware
from weblate.auth.models import User, get_anonymous
class MiddlewareTest(TestCase):
def view_method(self):
... |
import json
from absl import flags
from perfkitbenchmarker import container_service
from perfkitbenchmarker import context
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers import azure
from perfkitbenchmarker.providers.azure import azure_network
from perfkitbenchmarker.providers.azure import ut... |
from sense_energy import SenseAPITimeoutException, SenseAuthenticationException
from homeassistant import config_entries, setup
from homeassistant.components.sense.const import DOMAIN
from tests.async_mock import patch
async def test_form(hass):
"""Test we get the form."""
await setup.async_setup_component... |
__author__ = 'p3rf@google.com'
from absl import flags
flags.DEFINE_string('bq_project_id', None, 'Project Id which contains the query'
' dataset and table.')
flags.DEFINE_string('bq_dataset_id', None, 'Dataset Id which contains the query'
... |
import numpy as np
import unittest
import chainer
from chainer import testing
from chainer.testing import attr
from chainercv.links import FasterRCNNVGG16
from chainercv.links.model.faster_rcnn import FasterRCNNTrainChain
from chainercv.utils import generate_random_bbox
@testing.parameterize(
{'train': False},... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from nets import vgg
slim = tf.contrib.slim
class VGGATest(tf.test.TestCase):
def testBuild(self):
batch_size = 5
height, width = 224, 224
num_classes = 1000
with... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.