text stringlengths 213 32.3k |
|---|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import tensorflow as tf
from nets import inception
slim = tf.contrib.slim
class InceptionV1Test(tf.test.TestCase):
def testBuildClassificationNetwork(self):
batch_size = 5
hei... |
from tqdm import tqdm
import pandas as pd
from matchzoo.engine.base_preprocessor import BasePreprocessor
from matchzoo import DataPack
from .build_vocab_unit import build_vocab_unit
from .chain_transform import chain_transform
from . import units
tqdm.pandas()
class DIINPreprocessor(BasePreprocessor):
"""DIIN ... |
import asyncio
from datetime import timedelta
import logging
import time
from typing import Any, Dict, NamedTuple, Tuple, cast
from pyHS100 import SmartBulb, SmartDeviceException
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
ATTR_HS_COLOR,
SUPPORT_BRIGHTNESS,
SUPP... |
from datetime import timedelta
import os
import sqlite3
import pytest
from homeassistant.components.recorder import util
from homeassistant.components.recorder.const import DATA_INSTANCE, SQLITE_URL_PREFIX
from homeassistant.util import dt as dt_util
from .common import wait_recording_done
from tests.async_mock im... |
import logging
from libpurecool.const import (
FanPower,
FanSpeed,
FanState,
FocusMode,
HeatMode,
HeatState,
HeatTarget,
)
from libpurecool.dyson_pure_hotcool import DysonPureHotCool
from libpurecool.dyson_pure_hotcool_link import DysonPureHotCoolLink
from libpurecool.dyson_pure_state impo... |
from functools import partial
import itertools as it
from . import coroutine, return_value, reactor
from .mock import FakeReactor
try:
from twisted.internet.task import Cooperator
except ImportError:
pass
else:
from twisted.internet import task as real_task
from twisted.internet.defer import gatherR... |
import asyncio
import logging
from aioftp import Client, StatusCodeError
from haffmpeg.camera import CameraMjpeg
from haffmpeg.tools import IMAGE_JPEG, ImageFrame
import voluptuous as vol
from homeassistant.components.camera import PLATFORM_SCHEMA, Camera
from homeassistant.components.ffmpeg import DATA_FFMPEG
from ... |
import operator
import tree_format
from molecule import logger
from molecule import util
LOG = logger.get_logger(__name__)
class Scenarios(object):
"""
The Scenarios object consists of one to many scenario objects Molecule will
execute.
"""
def __init__(self, configs, scenario_name=None):
... |
from pymfy.api.devices.camera_protect import CameraProtect
from pymfy.api.devices.category import Category
from homeassistant.components.switch import SwitchEntity
from . import SomfyEntity
from .const import API, COORDINATOR, DOMAIN
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set u... |
from flask_script import Manager
from lemur.constants import SUCCESS_METRIC_STATUS, FAILURE_METRIC_STATUS
from lemur.extensions import sentry, metrics
from lemur.notifications.messaging import send_expiration_notifications
from lemur.notifications.messaging import send_authority_expiration_notifications
from lemur.no... |
from homeassistant.components.hassio.handler import HassioAPIError
from homeassistant.const import EVENT_HOMEASSISTANT_START
from homeassistant.setup import async_setup_component
from tests.async_mock import Mock, patch
async def test_hassio_discovery_startup(hass, aioclient_mock, hassio_client):
"""Test startu... |
from test import CollectorTestCase
from test import get_collector_config
from mock import Mock
from mock import patch
from diamond.collector import Collector
from disktemp import DiskTemperatureCollector
###############################################################################
class TestDiskTemperatureCollec... |
import string
import types
from typing import Mapping, MutableMapping, Optional, Sequence
import attr
from PyQt5.QtCore import pyqtSignal, QObject, Qt
from PyQt5.QtGui import QKeySequence, QKeyEvent
from qutebrowser.config import config
from qutebrowser.utils import usertypes, log, utils
from qutebrowser.keyinput im... |
import asyncio
from datetime import timedelta
from homeassistant.core import callback
from homeassistant.helpers import ratelimit
from homeassistant.util import dt as dt_util
async def test_hit(hass):
"""Test hitting the rate limit."""
refresh_called = False
@callback
def _refresh():
nonlo... |
import ftplib
import tempfile
import os
import stat
from stashutils.core import get_stash
from stashutils.fsi.base import BaseFSI, make_stat, calc_mode
from stashutils.fsi.errors import OperationFailure, IsDir, IsFile
from stashutils.fsi.errors import AlreadyExists
_stash = get_stash()
class FTPFSI(BaseFSI):
... |
import logging
import posixpath
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import data
from perfkitbenchmarker import errors
from perfkitbenchmarker import linux_virtual_machine
from perfkitbenchmarker import os_types
from perfkitbenchmarker import sample
from perfkitbenchmar... |
import logging
import threading
import time
from typing import Any
from typing import Callable
from kazoo.client import KazooClient
from kazoo.client import KazooState
from kazoo.exceptions import ConnectionClosedError
from kazoo.recipe.election import Election
from paasta_tools.deployd.common import PaastaThread
... |
import asyncio
from aiohttp import ClientError
from aiohttp.web_exceptions import HTTPForbidden
import pytest
from homeassistant.components.daikin.const import KEY_IP, KEY_MAC
from homeassistant.config_entries import (
SOURCE_DISCOVERY,
SOURCE_IMPORT,
SOURCE_USER,
SOURCE_ZEROCONF,
)
from homeassistan... |
import pytest
from homeassistant.components.NEW_DOMAIN import DOMAIN
import homeassistant.components.automation as automation
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_component
from tests.common import (
Mock... |
import asyncio
from pdunehd import DuneHDPlayer
from homeassistant.const import CONF_HOST
from .const import DOMAIN
PLATFORMS = ["media_player"]
async def async_setup(hass, config):
"""Set up the Dune HD component."""
return True
async def async_setup_entry(hass, config_entry):
"""Set up a config e... |
import contextlib
import unittest
from absl import flags
import mock
from perfkitbenchmarker import errors
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.configs import benchmark_config_spec
from perfkitbenchmarker.providers.gcp import gcp_tpu
from perfkitbenchmarker.providers.gcp import util
from tes... |
from datetime import timedelta
from bsblan import BSBLan, BSBLanConnectionError
from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.core import HomeAssistant
from homeassista... |
import urwid
def question():
return urwid.Pile([urwid.Edit(('I say', u"What is your name?\n"))])
def answer(name):
return urwid.Text(('I say', u"Nice to meet you, " + name + "\n"))
class ConversationListBox(urwid.ListBox):
def __init__(self):
body = urwid.SimpleFocusListWalker([question()])
... |
from __future__ import absolute_import
import logging
import time
from absl import flags
import boto3
# This is the path that we SCP object_storage_interface to.
from providers import object_storage_interface
import six
FLAGS = flags.FLAGS
class S3Service(object_storage_interface.ObjectStorageServiceBase):
"""A... |
from functional.execution import ExecutionEngine
from functional.transformations import CACHE_T
class Lineage(object):
"""
Class for tracking the lineage of transformations, and applying them to a given sequence.
"""
def __init__(self, prior_lineage=None, engine=None):
"""
Construct ... |
from pymata_express.pymata_express_serial import serial
from homeassistant import config_entries, setup
from homeassistant.components.firmata.const import CONF_SERIAL_PORT, DOMAIN
from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant
from tests.async_mock import patch
async def tes... |
import os.path as op
import pytest
import numpy as np
from mne.datasets.testing import data_path
from mne.io import read_raw_nirx, BaseRaw, read_raw_fif
from mne.preprocessing.nirs import optical_density, beer_lambert_law
from mne.utils import _validate_type
from mne.datasets import testing
from mne.externals.pymatr... |
import io
import os
import shutil
from mako import exceptions, util, lexer, parsetree
from mako.lookup import TemplateLookup
from mako.template import Template
from markupsafe import Markup # It's ok, Mako requires it
from nikola.plugin_categories import TemplateSystem
from nikola.utils import makedirs, get_logger
... |
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 Handler import Handler
try:
import zmq
except ImportError:
zmq = None
class zmqHandler (Handler):
"""
Implements the abstract Handler class
Sending data to a Zer0MQ pub channel
"""
def __init__(self, config=None):
"""
Create a new instance of zmqHandler class
... |
import os
import json
from types import ModuleType
import flexx
from flexx import ui, app
from urllib.request import urlopen, Request
from uiexample import create_ui_example
THIS_DIR = os.path.dirname(os.path.abspath(__file__))
DOC_DIR = os.path.abspath(os.path.join(THIS_DIR, '..'))
EXAMPLES_DIR = os.path.join(os.p... |
import logging
import pytest
from homeassistant.components.sentry import get_channel, process_before_send
from homeassistant.components.sentry.const import (
CONF_DSN,
CONF_ENVIRONMENT,
CONF_EVENT_CUSTOM_COMPONENTS,
CONF_EVENT_HANDLED,
CONF_EVENT_THIRD_PARTY_PACKAGES,
CONF_TRACING,
CONF_T... |
import unittest, sys
from lxml.tests.common_imports import make_doctest, doctest
import lxml.html
from lxml.html import html_parser, XHTML_NAMESPACE
class FrameTest(unittest.TestCase):
def test_parse_fragments_fromstring(self):
parser = lxml.html.HTMLParser(encoding='utf-8', remove_comments=True)
... |
import pkgutil
import numpy
import copyreg
import types
import dedupe.variables
import dedupe.variables.base as base
from dedupe.variables.base import MissingDataType
from dedupe.variables.interaction import InteractionType
for _, module, _ in pkgutil.iter_modules(dedupe.variables.__path__,
... |
import numpy as np
import opt_einsum
import pytest
from tensornetwork import Node
from tensornetwork.contractors.opt_einsum_paths import utils
def check_path(calculated_path, correct_path):
if not isinstance(calculated_path, list):
return False
if len(calculated_path) != len(correct_path):
return False
... |
from datetime import timedelta
import logging
from typing import Any, Dict, List, Optional
import voluptuous as vol
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
SERVICE_TOGGLE,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_ON,
)
import homeassistant.helpers.config... |
import re
from datetime import datetime
from functools import wraps
from django.urls import reverse
from django.utils.dateformat import DateFormat
from django.utils.timezone import is_aware
from django.utils.timezone import localtime
from django.utils.translation import gettext as _
class Crumb(object):
"""
... |
from .asserts import assert_equals_with_unidiff
class OutputCollector:
def __init__(self):
from unit_tests.myStringIO import StringIO
self.stream = StringIO()
self.getvalue = self.stream.getvalue
def write(self,data):
self.stream.write(data)
def should_be(self, expected):
... |
from datetime import datetime, timezone
import pytest
from dateutil.tz import tzoffset
from twtxt.parser import make_aware, parse_iso8601
from twtxt.parser import parse_tweet, parse_tweets
from twtxt.models import Source
def test_make_aware():
"""Test making unaware datetime objects tzinfo aware."""
aware ... |
import os
from gitless import core
from . import helpers, pprint
def parser(subparsers, repo):
"""Adds the status parser to the given subparsers object."""
desc = 'show status of the repo'
status_parser = subparsers.add_parser(
'status', help=desc, description=desc.capitalize(), aliases=['st'])
statu... |
import pytest
from homeassistant.components import vacuum
from homeassistant.components.demo.vacuum import (
DEMO_VACUUM_BASIC,
DEMO_VACUUM_COMPLETE,
DEMO_VACUUM_MINIMAL,
DEMO_VACUUM_MOST,
DEMO_VACUUM_NONE,
DEMO_VACUUM_STATE,
FAN_SPEEDS,
)
from homeassistant.components.vacuum import (
... |
from aioguardian import Client
from aioguardian.errors import GuardianError
import voluptuous as vol
from homeassistant import config_entries, core
from homeassistant.const import CONF_IP_ADDRESS, CONF_PORT
from homeassistant.core import callback
from .const import CONF_UID, DOMAIN, LOGGER # pylint:disable=unused-i... |
from homeassistant.components.geonetnz_volcano import DOMAIN, FEED
from tests.async_mock import AsyncMock, patch
async def test_component_unload_config_entry(hass, config_entry):
"""Test that loading and unloading of a config entry works."""
config_entry.add_to_hass(hass)
with patch(
"aio_geojso... |
from homeassistant.core import callback
from homeassistant.helpers.device_registry import async_get_registry as get_dev_reg
from .const import DOMAIN, LOGGER
@callback
def async_add_acmeda_entities(
hass, entity_class, config_entry, current, async_add_entities
):
"""Add any new entities."""
hub = hass.d... |
import operator
import hypothesis
from hypothesis import strategies
import pytest
from PyQt5.QtCore import Qt, QEvent, pyqtSignal
from PyQt5.QtGui import QKeyEvent, QKeySequence
from PyQt5.QtWidgets import QWidget
from unit.keyinput import key_data
from qutebrowser.keyinput import keyutils
@pytest.fixture(params=k... |
import os
import signal
import time
from http.client import BadStatusLine
import pytest
import portend
import cherrypy
import cherrypy.process.servers
from cherrypy.test import helper
engine = cherrypy.engine
thisdir = os.path.join(os.getcwd(), os.path.dirname(__file__))
class Dependency:
def __init__(self,... |
import typing
import keras
import matchzoo
from matchzoo.engine.base_model import BaseModel
from matchzoo.engine.param import Param
from matchzoo.engine.param_table import ParamTable
from matchzoo.engine import hyper_spaces
class ArcII(BaseModel):
"""
ArcII Model.
Examples:
>>> model = ArcII()... |
from homeassistant.helpers import intent
async def test_recent_items_intent(hass, sl_setup):
"""Test recent items."""
await intent.async_handle(
hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}}
)
await intent.async_handle(
hass, "test", "HassShoppingListAddItem", {... |
import logging
from itertools import cycle
from netort.resource import manager as resource
from . import info
from .module_exceptions import AmmoFileError
class HttpAmmo(object):
'''
Represents HTTP missile
>>> print HttpAmmo('/', []).to_s() # doctest: +NORMALIZE_WHITESPACE
GET / HTTP/1.1
>>... |
from homeassistant.components.switch import DOMAIN, SwitchEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from . import AqualinkEntity, refresh_system
from .const import DOMAIN as AQUALINK_DOMAIN
PARALLEL_UPDATES = 0
async def async_setup_entry... |
import sys
import pytest
import pygal
from pygal.etree import etree
from . import get_data
@pytest.fixture
def etreefx(request):
"""Fixture allowing to test with builtin etree and lxml"""
if request.param == 'etree':
etree.to_etree()
if request.param == 'lxml':
etree.to_lxml()
def py... |
import rumps
class AwesomeStatusBarApp(rumps.App):
@rumps.clicked("Preferences")
def prefs(self, _):
rumps.alert("jk! no preferences available!")
@rumps.clicked("Silly button")
def onoff(self, sender):
sender.state = not sender.state
@rumps.clicked("Say hi")
def sayhi(self, _... |
import pywink
import voluptuous as vol
from homeassistant.components.lock import LockEntity
from homeassistant.const import (
ATTR_CODE,
ATTR_ENTITY_ID,
ATTR_MODE,
ATTR_NAME,
STATE_UNKNOWN,
)
import homeassistant.helpers.config_validation as cv
from . import DOMAIN, WinkDevice
SERVICE_SET_VACATI... |
from Handler import Handler
from graphite import GraphiteHandler
class HostedGraphiteHandler(Handler):
def __init__(self, config=None):
"""
Create a new instance of the HostedGraphiteHandler class
"""
# Initialize Handler
Handler.__init__(self, config)
self.key =... |
import json
import os
from radicale import item as radicale_item
class CollectionMetaMixin:
def __init__(self):
super().__init__()
self._meta_cache = None
self._props_path = os.path.join(
self._filesystem_path, ".Radicale.props")
def get_meta(self, key=None):
# r... |
from __future__ import absolute_import, unicode_literals
import logging
from libtmux.exc import TmuxSessionExists
from libtmux.pane import Pane
from libtmux.server import Server
from libtmux.session import Session
from libtmux.window import Window
from . import exc
from .util import run_before_script
logger = logg... |
import logging
import voluptuous as vol
from homeassistant.components.cover import PLATFORM_SCHEMA, CoverEntity
from homeassistant.const import CONF_NAME, CONF_TYPE, STATE_OPEN
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.restore_state import RestoreEntity
from . import (
CONF... |
from unittest import TestCase
import numpy as np
from scipy.sparse import csr_matrix
import scattertext
from scattertext.CSRMatrixTools import CSRMatrixFactory
class TestCSRMatrixFactory(TestCase):
def test_main(self):
mat_factory = CSRMatrixFactory()
mat_factory[0, 0] = 4
mat_factory[1, 5] = 3
mat = mat_... |
import collections
import functools
import json
import logging
import re
from absl import flags
from perfkitbenchmarker import context
from perfkitbenchmarker import errors
from perfkitbenchmarker import virtual_machine
from perfkitbenchmarker import vm_util
import six
FLAGS = flags.FLAGS
RATE_LIMITED_MESSAGE = 'Rat... |
import asyncio
from datetime import timedelta
from functools import partial
import logging
from pathlib import Path
from typing import Optional
from oauthlib.oauth2 import AccessDeniedError
import requests
from ring_doorbell import Auth, Ring
from homeassistant.const import __version__
from homeassistant.core import... |
from django.conf import settings
from django.contrib import admin
from django.contrib.admin import AdminSite
from django.contrib.auth.views import LogoutView
from django.shortcuts import render
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from django.views.decorators.cache imp... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import math
from compare_gan.metrics import eval_task
import numpy as np
import tensorflow as tf
class KIDScoreTask(eval_task.EvalTask):
"""Evaluation task for the KID score."""
_LABEL = "kid_score"
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import abc
from compare_gan import utils
import gin
import six
import tensorflow as tf
@six.add_metaclass(abc.ABCMeta)
class _Module(object):
"""Base class for architectures.
Long term this will be repl... |
import logging
import bthomehub5_devicelist
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
CONF_... |
import string
class InvalidInterpolation(Exception):
def __init__(self, string, place):
self.string = string
self.place = place
class Interpolator(object):
"""
Configuration options may contain environment variables. For example,
suppose the shell contains ``VERIFIER_NAME=testinfra... |
from random import randint
from pylatex import Document, LongTabu, Tabu, Center
from pylatex.utils import bold
def genenerate_tabus():
geometry_options = {
"landscape": True,
"margin": "1.5in",
"headheight": "20pt",
"headsep": "10pt",
"includeheadfoot": True
}
doc ... |
import sys
from pscript.functions import py2js, evaljs
from pscript.stdlib import get_std_info, get_partial_std_lib
from ._loop import loop, this_is_js # noqa - import from here by tests
from ._component import Component
from ._property import Property
from ._js import create_js_component_class, JS_EVENT
class St... |
from ReText import globalSettings
from ReText.syncscroll import SyncScroll
from ReText.preview import ReTextWebPreview
from PyQt5.QtCore import QStandardPaths
from PyQt5.QtGui import QDesktopServices
from PyQt5.QtNetwork import QNetworkDiskCache
from PyQt5.QtWebKit import QWebSettings
from PyQt5.QtWebKitWidgets impor... |
import json
import pytest
from marshmallow import ValidationError
from lemur.pending_certificates.views import * # noqa
from .vectors import (
CSR_STR,
INTERMEDIATE_CERT_STR,
VALID_ADMIN_API_TOKEN,
VALID_ADMIN_HEADER_TOKEN,
VALID_USER_HEADER_TOKEN,
WILDCARD_CERT_STR,
)
def test_increment_a... |
from django.core.management import call_command
from django.core.management.base import CommandError
from django.test import TestCase
from weblate.auth.models import Group, User
from weblate.trans.tests.utils import TempDirMixin, get_test_file
class CommandTest(TestCase, TempDirMixin):
"""Test for management co... |
import pytest
import os
from yandextank.common.util import get_test_path
from yandextank.plugins.DataUploader.cli import from_tank_config, get_logger
@pytest.mark.parametrize('test_dir, expected', [
(os.path.join(get_test_path(), 'yandextank/plugins/DataUploader/tests/test_postloader/test_empty'), (None, {})),
... |
import os
from perfkitbenchmarker import vm_util
LAPACK_VERSION = '3.6.1'
LAPACK_FOLDER = 'lapack-%s' % LAPACK_VERSION
LAPACK_TAR = '%s.tgz' % LAPACK_FOLDER
LAPACK_URL = 'https://www.netlib.org/lapack/%s' % LAPACK_TAR
LAPACK_DIR = os.path.join(vm_util.VM_TMP_DIR, LAPACK_FOLDER)
PACKAGE_NAME = 'lapack'
PREPROVISIONED_... |
from datetime import datetime
import json
from aiokafka import AIOKafkaProducer
import voluptuous as vol
from homeassistant.const import (
CONF_IP_ADDRESS,
CONF_PASSWORD,
CONF_PORT,
CONF_USERNAME,
EVENT_HOMEASSISTANT_STOP,
EVENT_STATE_CHANGED,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
)
impor... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import logging
from compare_gan.metrics import eval_task
from compare_gan.metrics import image_similarity
import numpy as np
from six.moves import range
import tensorflow as tf
class MultiscaleSS... |
import datetime
import logging
import requests
from tank_utility import auth, device as tank_monitor
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_DEVICES, CONF_EMAIL, CONF_PASSWORD, PERCENTAGE
import homeassistant.helpers.config_validation ... |
from homeassistant.components.lock import DOMAIN, LockEntity
from . import FIBARO_DEVICES, FibaroDevice
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Fibaro locks."""
if discovery_info is None:
return
add_entities(
[FibaroLock(device) for device in h... |
import datetime
import decimal
import logging
import sqlalchemy
from sqlalchemy.orm import scoped_session, sessionmaker
import voluptuous as vol
from homeassistant.components.recorder import CONF_DB_URL, DEFAULT_DB_FILE, DEFAULT_URL
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const... |
from flexx import flx
class Redirect(flx.Widget):
def init(self):
self.but1 = flx.Button(text='Redirect')
self.but2 = flx.Button(text='Open new page')
@flx.reaction('but1.pointer_click')
def on_redirect(self, *events):
global window
window.location.href = 'http:/... |
import os
import re
import hvac
from flask import current_app
from lemur.common.defaults import common_name, country, state, location, organizational_unit, organization
from lemur.common.utils import parse_certificate
from lemur.plugins.bases import DestinationPlugin
from lemur.plugins.bases import SourcePlugin
from... |
import logging
from requests.exceptions import ConnectTimeout, HTTPError
from skybellpy import Skybell
import voluptuous as vol
from homeassistant.const import (
ATTR_ATTRIBUTION,
CONF_PASSWORD,
CONF_USERNAME,
__version__,
)
import homeassistant.helpers.config_validation as cv
from homeassistant.help... |
import asyncio
from datetime import timedelta
import ssl
from aiohttp import CookieJar
import aiounifi
from aiounifi.controller import (
DATA_CLIENT_REMOVED,
DATA_EVENT,
SIGNAL_CONNECTION_STATE,
SIGNAL_DATA,
)
from aiounifi.events import (
ACCESS_POINT_CONNECTED,
GATEWAY_CONNECTED,
SWITCH_... |
import socket
import mock
import pytest
from paasta_tools import generate_services_file
MOCK_NAMESPACES = [
("foo.main", {"proxy_port": 1024}),
("bar.canary", {"proxy_port": 1025}),
]
@pytest.yield_fixture
def mock_namespaces():
with mock.patch(
"paasta_tools.generate_services_file.get_all_na... |
import argparse
import matplotlib.pyplot as plt
import chainer
from chainercv.datasets import coco_bbox_label_names
from chainercv.datasets import coco_instance_segmentation_label_names
from chainercv.links import FasterRCNNFPNResNet101
from chainercv.links import FasterRCNNFPNResNet50
from chainercv.links import Ma... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import subprocess
from absl import logging
from absl.testing import _bazelize_command
from absl.testing import absltest
from absl.testing import parameterized
@parameterized.named_parameters(
... |
import contextlib
import unittest
from absl import flags
from absl.testing import flagsaver
import mock
from perfkitbenchmarker import benchmark_spec
from perfkitbenchmarker import configs
from perfkitbenchmarker import errors
from perfkitbenchmarker import linux_benchmarks
from perfkitbenchmarker import vm_util
fro... |
import numpy as np
from ._logging import logger
from ..defaults import _handle_default
def _set_pandas_dtype(df, columns, dtype):
"""Try to set the right columns to dtype."""
for column in columns:
df[column] = df[column].astype(dtype)
logger.info('Converting "%s" to "%s"...' % (column, dtyp... |
import os
from slacker import Slacker
def post_slack():
"""Post slack message."""
try:
token = os.environ['SLACK_TOKEN']
slack = Slacker(token)
obj = slack.chat.post_message('#general', 'Hello fellow slackers!')
print(obj.successful, obj.__dict__['body']['channel'], obj.__dic... |
from homeassistant.const import DEVICE_CLASS_TIMESTAMP
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import Entity
import homeassistant.util.dt as dt_util
from .const import DATA_UPDATED, DOMAIN, PRAYER_TIMES_ICON, SENSOR_TYPES
async def async_setup_entry(ha... |
import urwid
class MultiPudding(urwid.Widget):
_sizing = frozenset(['flow', 'box'])
def rows(self, size, focus=False):
return 1
def render(self, size, focus=False):
if len(size) == 1:
(maxcol,) = size
maxrow = 1
else:
(maxcol, maxrow) = size
... |
import distutils.cmd
import distutils.command.build
import distutils.command.build_py
import distutils.command.install
import distutils.command.install_data
import distutils.dir_util
import distutils.dist
import glob
import os.path
import platform
import sys
from distutils.log import info
try:
import distro
excep... |
import pyvera as pv
from homeassistant.core import HomeAssistant
from .common import ComponentFactory, new_simple_controller_config
from tests.async_mock import MagicMock
async def test_switch(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = ... |
from datetime import timedelta
import logging
from async_timeout import timeout
from pynzbgetapi import NZBGetAPI, NZBGetAPIException
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_PORT,
CONF_SCAN_INTERVAL,
CONF_SSL,
CONF_USERNAME,
CONF_VERIFY_SSL,
)
from homeassistant.h... |
import pkgutil
import types
import sys
import pathlib
import importlib
import argparse
from typing import Callable, Iterator, List, Optional, Set, Tuple
import attr
from PyQt5.QtCore import pyqtSlot
from qutebrowser import components
from qutebrowser.config import config
from qutebrowser.utils import log, standardd... |
from flexx import flx
from flexxamples.demos.splines import Splines
from flexxamples.demos.twente import Twente
from flexxamples.demos.drawing import Drawing
class Demo(flx.Widget):
def init(self):
with flx.TabLayout():
Splines(title='Spline demo')
Twente(title='Temperature vis')
... |
import numpy as np
import unittest
import chainer
from chainer.datasets import TupleDataset
from chainer.iterators import SerialIterator
from chainer import testing
from chainercv.extensions import InstanceSegmentationVOCEvaluator
from chainercv.utils.testing import attr
from chainermn import create_communicator
... |
import pandas as pd
import pytz
import pytest
from qstrader.broker.portfolio.portfolio import Portfolio
from qstrader.broker.portfolio.portfolio_event import PortfolioEvent
from qstrader.broker.transaction.transaction import Transaction
def test_initial_settings_for_default_portfolio():
"""
Test that the in... |
import numpy as np
from ..core import indexing
from ..core.utils import Frozen, FrozenDict, close_on_error
from ..core.variable import Variable
from .common import AbstractDataStore, BackendArray, BackendEntrypoint
from .file_manager import CachingFileManager
from .locks import HDF5_LOCK, NETCDFC_LOCK, combine_locks,... |
import logging
from pyqwikswitch.qwikswitch import SENSORS
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.core import callback
from . import DOMAIN as QWIKSWITCH, QSEntity
_LOGGER = logging.getLogger(__name__)
async def async_setup_platform(hass, _, add_entities, discove... |
import logging
import math
import voluptuous as vol
from homeassistant import util
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_UNIT_OF_MEASUREMENT,
CONF_NAME,
EVENT_HOMEASSISTANT_START,
PERCENTAGE,
STATE_UNKNOWN,
TEMP_CELSIUS,
TEMP_FA... |
import numpy as np
import pandas as pd
from conftest import MAX_TS, random_split
from yandextank.aggregator.chopper import TimeChopper
class TestChopper(object):
def test_one_chunk(self, data):
chopper = TimeChopper([data], 5)
result = list(chopper)
assert len(result) == MAX_TS
c... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.