text stringlengths 213 32.3k |
|---|
import mock
from paasta_tools import adhoc_tools
from paasta_tools.utils import DeploymentsJsonV2
from paasta_tools.utils import NoConfigurationForServiceError
def test_get_default_interactive_config():
with mock.patch(
"paasta_tools.adhoc_tools.load_adhoc_job_config", autospec=True
) as mock_load_a... |
import asyncio
import aiohttp
import aioshelly
import pytest
from homeassistant import config_entries, setup
from homeassistant.components.shelly.const import DOMAIN
from tests.async_mock import AsyncMock, Mock, patch
from tests.common import MockConfigEntry
MOCK_SETTINGS = {
"name": "Test name",
"device":... |
import queue
import numpy as np
from qstrader import settings
from qstrader.broker.broker import Broker
from qstrader.broker.fee_model.fee_model import FeeModel
from qstrader.broker.portfolio.portfolio import Portfolio
from qstrader.broker.transaction.transaction import Transaction
from qstrader.broker.fee_model.zer... |
import collections
from coverage.backward import iitems
from coverage.debug import SimpleReprMixin
from coverage.misc import contract, CoverageException, nice_pair
class Analysis(object):
"""The results of analyzing a FileReporter."""
def __init__(self, data, file_reporter, file_mapper):
self.data ... |
from django.utils.functional import cached_property
from django.utils.text import format_lazy
from django.utils.translation import gettext
from django.utils.translation import gettext_lazy as _
from weblate.checks.models import CHECKS
class FilterRegistry:
@cached_property
def full_list(self):
resul... |
import sys
import os
import mne
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-i", "--in", dest="in_fname",
help="Input raw FIF file", metavar="FILE")
parser.add_option("-o", dest="out_fname",... |
import collections
import csv
import json
import re
import tempfile
import unittest
import uuid
from absl import flags
import mock
from perfkitbenchmarker import pkb # pylint: disable=unused-import
from perfkitbenchmarker import publisher
from perfkitbenchmarker import sample
from perfkitbenchmarker import vm_util
f... |
import functools
import os
import numpy as np
import pandas as pd
import pytz
from qstrader import settings
class CSVDailyBarDataSource(object):
"""
Encapsulates loading, preparation and querying of CSV files of
daily 'bar' OHLCV data. The CSV files are converted into a intraday
timestamped Pandas D... |
from homeassistant import config_entries, data_entry_flow, setup
from homeassistant.components import ssdp
from homeassistant.components.isy994.config_flow import CannotConnect
from homeassistant.components.isy994.const import (
CONF_IGNORE_STRING,
CONF_RESTORE_LIGHT_STATE,
CONF_SENSOR_STRING,
CONF_TLS... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import logging
from compare_gan import datasets
from compare_gan import eval_utils
from compare_gan.metrics import eval_task
import numpy as np
class AccuracyTask(eval_task.EvalTask):
"""Evalua... |
import vcr
class MockSerializer:
def __init__(self):
self.serialize_count = 0
self.deserialize_count = 0
self.load_args = None
def deserialize(self, cassette_string):
self.serialize_count += 1
self.cassette_string = cassette_string
return {"interactions": []}
... |
import pywink
from homeassistant.components.cover import ATTR_POSITION, CoverEntity
from . import DOMAIN, WinkDevice
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Wink cover platform."""
for shade in pywink.get_shades():
_id = shade.object_id() + shade.name()
... |
import io
import textwrap
import re
import uuid
import pytest
mhtml = pytest.importorskip('qutebrowser.browser.webkit.mhtml')
try:
import cssutils
except ImportError:
cssutils = None
@pytest.fixture(autouse=True)
def patch_uuid(monkeypatch):
monkeypatch.setattr(uuid, "uuid4", lambda: "UUID")
class ... |
import os
from stash.tests.stashtest import StashTestCase
class PwdTests(StashTestCase):
"""tests for the 'pwd' command."""
cwd = os.path.expanduser("~")
def test_help(self):
"""test 'pwd --help'."""
output = self.run_command("pwd --help")
self.assertIn("pwd", output)
se... |
import os
import diamond.collector
class OneWireCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(OneWireCollector, self).get_default_config_help()
config_help.update({
})
return config_help
def get_default_config(self):
"... |
from os import path
import numpy as np
from ...utils import warn, fill_doc, _check_option
from ...channels.layout import _topo_to_sphere
from ..constants import FIFF
from ..utils import (_mult_cal_one, _find_channels, _create_chs, read_str)
from ..meas_info import _empty_info
from ..base import BaseRaw
from ...annot... |
import mock
from pytest import raises
from paasta_tools import paasta_cluster_boost
FAKE_SLAVE_DATA = [
{
"datacenter": "westeros-1",
"ecosystem": "stagef",
"habitat": "uswest1cstagef",
"instance_type": "c3.4xlarge",
"kwatest": "foo",
"pool": "default",
"re... |
import os
import fnmatch
DOIT_CONFIG = {
'default_tasks': ['flake8', 'test'],
'reporter': 'executed-only',
}
def recursive_glob(path, pattern):
"""recursively walk path directories and return files matching the pattern"""
for root, dirnames, filenames in os.walk(path, followlinks=True):
for ... |
import logging
import os
import shutil
import subprocess
import tempfile
import voluptuous as vol
from homeassistant.components.tts import CONF_LANG, PLATFORM_SCHEMA, Provider
_LOGGER = logging.getLogger(__name__)
SUPPORT_LANGUAGES = ["en-US", "en-GB", "de-DE", "es-ES", "fr-FR", "it-IT"]
DEFAULT_LANG = "en-US"
P... |
import diamond.collector
import urllib2
import time
try:
import json
except ImportError:
import simplejson as json
class CelerymonCollector(diamond.collector.Collector):
LastCollectTime = None
def get_default_config_help(self):
config_help = super(CelerymonCollector, self).get_default_conf... |
import logging
from spiderpy.spiderapi import SpiderApi, SpiderApiException, UnauthorizedException
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_PASSWORD, CONF_SCAN_INTERVAL, CONF_USERNAME
from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
_LOGGER = logging.ge... |
from urllib.error import HTTPError
from urllib.error import URLError
from urllib.parse import urlsplit
from urllib.request import urlopen
from bs4 import BeautifulSoup
from django.contrib.contenttypes.models import ContentType
from django.contrib.sites.models import Site
from django.urls import Resolver404
from djan... |
import unittest
import torch
import torch.nn as tnn
import torch.autograd as autograd
from common import gpu_test
class TestPyTorch(unittest.TestCase):
# PyTorch smoke test based on http://pytorch.org/tutorials/beginner/nlp/deep_learning_tutorial.html
def test_nn(self):
torch.manual_seed(31337)
... |
from __future__ import absolute_import
import threading
version = """$Id: 04-1.html,v 1.3 2006/12/05 17:45:12 majid Exp $"""
class RWLock:
"""
A simple reader-writer lock Several readers can hold the lock
simultaneously, XOR one writer. Write locks have priority over reads to
prevent write starvatio... |
import aiohttp
from homeassistant.components.atag import DOMAIN
from homeassistant.config_entries import ENTRY_STATE_SETUP_RETRY
from homeassistant.core import HomeAssistant
from tests.async_mock import patch
from tests.components.atag import init_integration
from tests.test_util.aiohttp import AiohttpClientMocker
... |
import os
from weblate.addons.base import BaseAddon
from weblate.utils.render import render_template
from weblate.utils.site import get_site_url
class BaseScriptAddon(BaseAddon):
"""Base class for script executing addons."""
icon = "script.svg"
script = None
add_file = None
alert = "AddonScript... |
import logging
import blebox_uniapi
import pytest
from homeassistant.components.cover import (
ATTR_CURRENT_POSITION,
ATTR_POSITION,
DEVICE_CLASS_DOOR,
DEVICE_CLASS_GATE,
DEVICE_CLASS_SHUTTER,
STATE_CLOSED,
STATE_CLOSING,
STATE_OPEN,
STATE_OPENING,
SUPPORT_CLOSE,
SUPPORT_O... |
from twilio.rest import Client
from twilio.twiml import TwiML
import voluptuous as vol
from homeassistant.const import CONF_WEBHOOK_ID
from homeassistant.helpers import config_entry_flow
import homeassistant.helpers.config_validation as cv
from .const import DOMAIN
CONF_ACCOUNT_SID = "account_sid"
CONF_AUTH_TOKEN =... |
import logging
from gi.repository import Gio, GLib, GObject, GtkSource
from meld.conf import _
from meld.settings import bind_settings
log = logging.getLogger(__name__)
class MeldBuffer(GtkSource.Buffer):
__gtype_name__ = "MeldBuffer"
__gsettings_bindings__ = (
('highlight-syntax', 'highlight-sy... |
from typing import List, Optional
import voluptuous as vol
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_SUPPORTED_FEATURES,
CONF_DEVICE_ID,
CONF_DOMAIN,
CONF_ENTITY_ID,
CONF_TYPE,
SERVICE_CLOSE_COVER,
SERVICE_CLOSE_COVER_TILT,
SERVICE_OPEN_COVER,
SERVICE_OPEN_COVER_T... |
from homeassistant.const import DEVICE_CLASS_POWER, ENERGY_WATT_HOUR, POWER_WATT, VOLT
from homeassistant.helpers.entity import Entity
from .const import DOMAIN
TREND_SENSORS = {
"total_power": [
"Total consumption - Active power",
None,
POWER_WATT,
"total_power",
DEVICE_C... |
import argparse
import logging
import os
import pkgutil
import subprocess
import sys
import warnings
from typing import Any
from typing import List
from typing import Tuple
import argcomplete
import paasta_tools
from paasta_tools.cli import cmds
def load_method(module_name, method_name):
"""Return a function g... |
import asyncio
from collections import OrderedDict
import logging
import async_timeout
from pypoint import PointSession
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components.http import HomeAssistantView
from homeassistant.const import CONF_CLIENT_ID, CONF_CLIENT_SECRET
from... |
import json
import time
from absl import flags
from perfkitbenchmarker import errors
from perfkitbenchmarker import managed_memory_store
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers import azure
from perfkitbenchmarker.providers.azure import azure_network
FLAGS = flags.FLAGS
# 15min timeou... |
from typing import Any, Dict
# pylint: disable=import-error, no-member
import switchbot
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
from homeassistant.const import CONF_MAC, CONF_NAME, CONF_PASSWORD
import homeassistant.helpers.config_validation as cv
from homea... |
from arcam.fmj.client import Client
from arcam.fmj.state import State
import pytest
from homeassistant.components.arcam_fmj.const import DEFAULT_NAME
from homeassistant.components.arcam_fmj.media_player import ArcamFmj
from homeassistant.const import CONF_HOST, CONF_PORT
from tests.async_mock import Mock, patch
from... |
import pytest
from molecule.command import login
@pytest.fixture
def _instance(config_instance):
config_instance.state.change_state('created', True)
return login.Login(config_instance)
def test_execute(mocker, _instance):
_instance._config.command_args = {'host': 'instance-1'}
m = mocker.patch('m... |
import cherrypy
from cherrypy.test import helper
class SessionAuthenticateTest(helper.CPWebCase):
@staticmethod
def setup_server():
def check(username, password):
# Dummy check_username_and_password function
if username != 'test' or password != 'password':
re... |
import logging
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_NAME, CONF_PIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import Entity
from .const import CONF_DIFFERENTIAL, CONF_PIN_MODE, DOMAIN
from .entity import FirmataPinEntity
from .p... |
import logging
from aiofreepybox.exceptions import AuthorizationError, HttpRequestError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_HOST, CONF_PORT
from .const import DOMAIN # pylint: disable=unused-import
from .router import get_api
_LOGGER = logging.get... |
import unittest
from perfkitbenchmarker import stages
class RunStageParserTestCase(unittest.TestCase):
def setUp(self):
self._parser = stages.RunStageParser()
def testEmpty(self):
with self.assertRaises(ValueError):
self._parser.parse('')
def testInvalidItem(self):
with self.assertRaises(... |
import json
import pytest_bdd as bdd
bdd.scenarios('misc.feature')
@bdd.then(bdd.parsers.parse('the PDF {filename} should exist in the tmpdir'))
def pdf_exists(quteproc, tmpdir, filename):
path = tmpdir / filename
data = path.read_binary()
assert data.startswith(b'%PDF')
@bdd.when(bdd.parsers.parse('I... |
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_LOCK,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
STATE_UNLOCKED,
)
from tests.components.august.mocks import (
_create_august_with_devices,
... |
import itertools
import posixpath
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import disk
from perfkitbenchmarker import hpc_util
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_packages import ior
FLAGS = flags.FLAGS
flags.DEFINE_integer(
'ior_num_p... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import abc
import time
from perfkitbenchmarker import errors
from perfkitbenchmarker import vm_util
import six
_RESOURCE_REGISTRY = {}
def GetResourceClass(base_class, **kwargs):
"""Returns the subclass ... |
from ipaddress import ip_address
import logging
from aiohttp.hdrs import X_FORWARDED_FOR, X_FORWARDED_HOST, X_FORWARDED_PROTO
from aiohttp.web import HTTPBadRequest, middleware
from homeassistant.core import callback
_LOGGER = logging.getLogger(__name__)
# mypy: allow-untyped-defs
@callback
def async_setup_forwa... |
import pytest
from plumbum import PuttyMachine, SshMachine
from plumbum._testtools import xfail_on_pypy
@pytest.fixture(params=['default', '322'])
def ssh_port(request):
return request.param
class TestPuttyMachine:
@xfail_on_pypy
def test_putty_command(self, mocker, ssh_port):
local = mocker.p... |
from zope.index.text.lexicon import Lexicon
from zope.index.text.textindex import TextIndex
from zope.index.text.cosineindex import CosineIndex
from zope.index.text.setops import mass_weightedUnion
from BTrees.Length import Length
import math
import numpy
import logging
logger = logging.getLogger(__name__)
class C... |
import unittest
from perfkitbenchmarker import beam_pipeline_options
class BeamArgsOptionsTestCase(unittest.TestCase):
def testNoFlagsPassed(self):
options_list = beam_pipeline_options.GenerateAllPipelineOptions(
None, None, [], [])
self.assertListEqual(options_list, [])
def testAllFlagsPassed(... |
from weblate.lang.models import Language, Plural
from weblate.utils.management.base import BaseCommand
class Command(BaseCommand):
help = "Move all content from one language to other"
def add_arguments(self, parser):
parser.add_argument("source", help="Source language code")
parser.add_argum... |
import asyncio
import logging
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import SERVICE_TURN_OFF, SERVICE_TURN_ON, STATE_OFF, STATE_ON
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
from .const import (
ATTR_HUMIDITY,
AT... |
import argparse
import re
import chainer
from chainer import Link
import chainer.links.caffe.caffe_function as caffe
"""
Please download a weight from here.
http://www.robots.ox.ac.uk/%7Evgg/software/very_deep/caffe/VGG_ILSVRC_16_layers.caffemodel
"""
def rename(name):
m = re.match(r'conv(\d+)_(\d+)$', name)
... |
from homeassistant.components.rflink import EVENT_BUTTON_PRESSED
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import CoreState, State, callback
from tests.common import mock_restore_cache
from tests.components.r... |
import asyncio
import logging
from hatasmota.const import (
CONF_MAC,
CONF_MANUFACTURER,
CONF_MODEL,
CONF_NAME,
CONF_SW_VERSION,
)
from hatasmota.discovery import clear_discovery_topic
from hatasmota.mqtt import TasmotaMQTTClient
import voluptuous as vol
from homeassistant.components import mqtt,... |
import asyncio
import copy
import hmac
import json
import logging
from aiohttp.hdrs import AUTHORIZATION
from aiohttp.web import Request, Response
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components.binary_sensor import DEVICE_CLASSES_SCHEMA
from homeassistant.components.h... |
import socket
import diamond.collector
import os.path
import urlparse
import time
class OpenVPNCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(OpenVPNCollector, self).get_default_config_help()
config_help.update({
'instances': 'List of i... |
import asyncio
import json
import logging
import aiohttp
from aiohttp.hdrs import CONTENT_TYPE
import async_timeout
import voluptuous as vol
from homeassistant.const import ATTR_NAME, CONF_API_KEY, CONF_TIMEOUT, CONTENT_TYPE_JSON
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aioh... |
from datetime import timedelta
import pytest
from homeassistant.components import rfxtrx
from homeassistant.components.rfxtrx import DOMAIN
from homeassistant.util.dt import utcnow
from tests.async_mock import patch
from tests.common import MockConfigEntry, async_fire_time_changed
from tests.components.light.confte... |
import tensornetwork as tn
import pytest
import numpy as np
from tensornetwork.backends.abstract_backend import AbstractBackend
import tensornetwork.linalg
import tensornetwork.linalg.node_linalg
def test_replicate_nodes(backend):
a = tn.Node(np.random.rand(10, 10), backend=backend)
b = tn.Node(np.random.rand(10... |
import urwid
class QuestionnaireItem(urwid.WidgetWrap):
def __init__(self):
self.options = []
unsure = urwid.RadioButton(self.options, u"Unsure")
yes = urwid.RadioButton(self.options, u"Yes")
no = urwid.RadioButton(self.options, u"No")
display_widget = urwid.GridFlow([unsur... |
from ... import event
from . import Widget
class IFrame(Widget):
""" An iframe element, i.e. a container to show web-content.
Note that some websites do not allow themselves to be rendered in
a cross-source iframe.
The ``node`` of this widget is a
`<iframe> <https://developer.mozilla.org/doc... |
from collections import defaultdict
import six
from chainercv.chainer_experimental.datasets.sliceable.sliceable_dataset \
import _as_tuple
from chainercv.chainer_experimental.datasets.sliceable import SliceableDataset
class TupleDataset(SliceableDataset):
"""A sliceable version of :class:`chainer.datasets.T... |
import asyncio
from unittest.mock import Mock, patch
import pytest
from homeassistant import data_entry_flow
from homeassistant.components.logi_circle import config_flow
from homeassistant.components.logi_circle.config_flow import (
DOMAIN,
AuthorizationFailed,
LogiCircleAuthCallbackView,
)
from homeassi... |
import unittest
import logging
from gensim.sklearn_api import D2VTransformer
from gensim.test.utils import common_texts
class IteratorForIterable:
"""Iterator capable of folding into list."""
def __init__(self, iterable):
self._data = iterable
self._index = 0
def __next__(self):
... |
from aiohomekit.model.characteristics import CharacteristicsTypes
from aiohomekit.model.services import ServicesTypes
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_GAS,
DEVICE_CLASS_MOISTURE,
DEVICE_CLASS_MOTION,
DEVICE_CLASS_OCCUPANCY,
DEVICE_CLASS_OPENING,
DEVICE_CLASS_SM... |
import json
from datetime import timedelta
import arrow
import boto3
from moto import mock_sns, mock_sqs, mock_ses
from lemur.certificates.schemas import certificate_notification_output_schema
from lemur.plugins.lemur_aws.sns import format_message
from lemur.plugins.lemur_aws.sns import publish
from lemur.tests.fact... |
import importlib
import platform
import re
import warnings
from contextlib import contextmanager
from distutils import version
from unittest import mock # noqa: F401
import numpy as np
import pytest
from numpy.testing import assert_array_equal # noqa: F401
from pandas.testing import assert_frame_equal # noqa: F401... |
import logging
from collections import defaultdict
from gensim import utils
from gensim.corpora import Dictionary
from gensim.corpora import IndexedCorpus
from gensim.matutils import MmReader
from gensim.matutils import MmWriter
logger = logging.getLogger(__name__)
class UciReader(MmReader):
"""Reader of UCI ... |
from pyhap.const import (
CATEGORY_HUMIDIFIER,
HAP_REPR_AID,
HAP_REPR_CHARS,
HAP_REPR_IID,
HAP_REPR_VALUE,
)
from homeassistant.components.homekit.const import (
ATTR_VALUE,
CONF_LINKED_HUMIDITY_SENSOR,
PROP_MAX_VALUE,
PROP_MIN_STEP,
PROP_MIN_VALUE,
PROP_VALID_VALUES,
)
fro... |
import aiohttp
import pytest
from sharkiqpy import AylaApi, SharkIqAuthError
from homeassistant import config_entries, setup
from homeassistant.components.sharkiq.const import DOMAIN
from homeassistant.core import HomeAssistant
from .const import CONFIG, TEST_PASSWORD, TEST_USERNAME, UNIQUE_ID
from tests.async_mock... |
from django.utils.translation import gettext_lazy as _
from weblate.checks.base import TargetCheck
class PluralsCheck(TargetCheck):
"""Check for incomplete plural forms."""
check_id = "plurals"
name = _("Missing plurals")
description = _("Some plural forms are not translated")
def check_target... |
from __future__ import print_function
import posixpath
import re
from absl import flags
from perfkitbenchmarker import linux_packages
FLAGS = flags.FLAGS
flags.DEFINE_string('openmpi_version', '3.1.2',
'OpenMPI version to install, such as 3.1.2 and 4.0.2.'
'Set to empty to i... |
import six
import logging
import numpy as np
from pandas import DataFrame, MultiIndex, Series, DatetimeIndex, Index
import pandas as pd
# Used in global scope, do not remove.
from .._config import FAST_CHECK_DF_SERIALIZABLE
from .._util import NP_OBJECT_DTYPE
from ..exceptions import ArcticException
try: # 0.21+ C... |
import argparse
class RegisterLeafClasses(type):
def __init__(cls, name, bases, nmspc):
super(RegisterLeafClasses, cls).__init__(name, bases, nmspc)
if not hasattr(cls, 'registry'):
cls.registry = set()
cls.registry.add(cls)
cls.registry -= set(bases) # Remove base cla... |
import pytest
from homeassistant.components.device_tracker.const import DOMAIN, SOURCE_TYPE_BLUETOOTH
from homeassistant.const import CONF_PLATFORM, STATE_HOME, STATE_NOT_HOME
from homeassistant.setup import async_setup_component
from tests.async_mock import patch
from tests.common import async_fire_mqtt_message
@... |
import time
import jsonschema
try:
import simplejson as json
except ImportError:
import json
try:
from http import HTTPStatus
except ImportError:
import httplib as HTTPStatus
from flask import Flask
from flask import jsonify
from flask import request
from flasgger import Swagger
def drop_id_validate(... |
import logging
import re
import requests
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PREVIOUS_TRACK,
SUPPORT_STOP,
... |
import pickle
from src.config import CACHE_PATH, METADATA_PATH
from src.s3_client_deeposm import post_findings_to_s3
from src.single_layer_network import load_model, MODEL_METADATA_PATH
def main():
"""Post test results to an S3 bucket."""
with open(CACHE_PATH + 'raster_data_paths.pickle', 'r') as infile:
... |
from collections import Counter
import numpy as np
from .mixin import TransformerMixin, EstimatorMixin
from .base import _set_cv
from ..io.pick import _picks_to_idx
from ..parallel import parallel_func
from ..utils import logger, verbose
from .. import pick_types, pick_info
class EMS(TransformerMixin, EstimatorMix... |
from django.core.paginator import Paginator
from django.template import Context
from django.test import TestCase
from zinnia.context import get_context_first_matching_object
from zinnia.context import get_context_first_object
from zinnia.context import get_context_loop_positions
class ContextTestCase(TestCase):
... |
from datetime import timedelta
import voluptuous as vol
from homeassistant.components.binary_sensor import (
DEVICE_CLASSES_SCHEMA,
PLATFORM_SCHEMA,
BinarySensorEntity,
)
from homeassistant.const import (
CONF_COMMAND,
CONF_DEVICE_CLASS,
CONF_NAME,
CONF_PAYLOAD_OFF,
CONF_PAYLOAD_ON,
... |
from tensornetwork.block_sparse.blocksparsetensor import BlockSparseTensor
from tensornetwork.block_sparse.charge import U1Charge, BaseCharge
from tensornetwork.block_sparse.index import Index
import tensornetwork.block_sparse as bs
from tensornetwork.backends.symmetric import decompositions
import tensornetwork.backe... |
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 dropwizard import DropwizardCollector
##########################################################################
class TestDr... |
import pytest
from qutebrowser.browser import downloads, qtnetworkdownloads
@pytest.fixture
def manager(config_stub, cookiejar_and_cache):
"""A QtNetwork download manager."""
return qtnetworkdownloads.DownloadManager()
def test_download_model(qapp, qtmodeltester, manager):
"""Simple check for download... |
from homeassistant.const import STATE_OFF, STATE_ON
from tests.common import MockToggleEntity
ENTITIES = []
def init(empty=False):
"""Initialize the platform with entities."""
global ENTITIES
ENTITIES = (
[]
if empty
else [
MockToggleEntity("AC", STATE_ON),
... |
from abc import ABC, abstractmethod
from samsungctl import Remote
from samsungctl.exceptions import AccessDenied, ConnectionClosed, UnhandledResponse
from samsungtvws import SamsungTVWS
from samsungtvws.exceptions import ConnectionFailure
from websocket import WebSocketException
from homeassistant.const import (
... |
from homeassistant.const import STATE_UNKNOWN
from homeassistant.helpers import discovery
from homeassistant.setup import async_setup_component
from .common import NUMATO_CFG, mockup_raise
MOCKUP_ENTITY_IDS = {
"sensor.numato_adc_mock_port1",
}
async def test_failing_setups_no_entities(hass, numato_fixture, mo... |
import unittest
import numpy as np
import bqplot.pyplot as plt
class TestBqplot(unittest.TestCase):
def test_figure(self):
size = 100
scale = 100.0
np.random.seed(0)
x_data = np.arange(size)
y_data = np.cumsum(np.random.randn(size) * scale)
fig = plt.figure(title='... |
from datetime import timedelta
import logging
from pyhik.hikvision import HikCamera
import voluptuous as vol
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_CONNECTIVITY,
DEVICE_CLASS_MOTION,
PLATFORM_SCHEMA,
BinarySensorEntity,
)
from homeassistant.const import (
ATTR_LAST_TRIP... |
import abodepy.helpers.constants as CONST
import pytest
from tests.common import load_fixture
from tests.components.light.conftest import mock_light_profiles # noqa
@pytest.fixture(autouse=True)
def requests_mock_fixture(requests_mock):
"""Fixture to provide a requests mocker."""
# Mocks the login response... |
import copy
from homeassistant.components.calendar import CalendarEventDevice, get_date
import homeassistant.util.dt as dt_util
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Demo Calendar platform."""
calendar_data_future = DemoGoogleCalendarDataFuture()
calendar_dat... |
from homeassistant.components import islamic_prayer_times
import homeassistant.util.dt as dt_util
from . import NOW, PRAYER_TIMES, PRAYER_TIMES_TIMESTAMPS
from tests.async_mock import patch
from tests.common import MockConfigEntry
async def test_islamic_prayer_times_sensors(hass, legacy_patchable_time):
"""Tes... |
from unittest import TestCase
import pandas as pd
from scattertext.TermDocMatrixFromFrequencies import TermDocMatrixFromFrequencies
from scattertext.termcompaction.CompactTerms import CompactTerms
class TestCompactTerms(TestCase):
def test_get_term_indices_to_compact(self):
'''
term_doc_matrix = TermDocMatrix... |
import unittest
import chainer
from chainer.backends import cuda
from chainer.functions import relu
from chainer import testing
from chainer.testing import attr
from chainercv.links import SeparableConv2DBNActiv
import numpy as np
def _add_one(x):
return x + 1
@testing.parameterize(*testing.product({
'd... |
import os.path as op
import numpy as np
import pytest
from numpy.testing import (assert_array_equal, assert_array_almost_equal,
assert_allclose, assert_equal)
from mne import io, read_events, Epochs, pick_types
from mne.decoding import (Scaler, FilterEstimator, PSDEstimator, Vectorizer,
... |
import numpy as np
from scipy.sparse import csr_matrix
from scattertext.termranking.TermRanker import TermRanker
class DocLengthNormalizedFrequencyRanker(TermRanker):
'''Ranks terms by their document-length adjusted frequency instead of their raw frequency.
This means that each term has a document-specific weight... |
from pysmartthings import Attribute, Capability
import pytest
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
ATTR_HS_COLOR,
ATTR_TRANSITION,
DOMAIN as LIGHT_DOMAIN,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_COLOR_TEMP,
SUPPORT_TRANSITION,
)
from hom... |
import logging
from socket import gaierror
import voluptuous as vol
from xiaomi_gateway import MULTICAST_PORT, XiaomiGateway, XiaomiGatewayDiscovery
from homeassistant import config_entries
from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME, CONF_PORT
from homeassistant.core import callback
from homeassi... |
from mock import MagicMock
from mock import patch
from paasta_tools.cli.cmds import get_latest_deployment
def test_get_latest_deployment(capfd):
mock_args = MagicMock(service="", deploy_group="", soa_dir="")
with patch(
"paasta_tools.cli.cmds.get_latest_deployment.get_currently_deployed_sha",
... |
import sys
import os
import dulwich
from dulwich import porcelain
from dulwich.walk import Walker
from gittle import Gittle
class GitError(Exception):
def __init__(self, arg):
Exception.__init__(self, arg)
def _find_repo(path):
subdirs = os.walk(path).next()[1]
if '.git' in subdirs:
ret... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.