text stringlengths 213 32.3k |
|---|
from __future__ import print_function
import argparse
import os
import sys
def main(args):
p = argparse.ArgumentParser(description=__doc__)
p.add_argument("-c", "--no-create", action="store_true", help="do not create nonexistant files")
p.add_argument("file", action="store", nargs="+", help="one or more... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import patch
from diamond.collector import Collector
from openvpn import OpenVPNCollector
##########################################################################
class TestOpenVPNCollector(CollectorTestC... |
from typing import List, Optional
from pyinsteon.constants import ThermostatMode
from pyinsteon.operating_flag import CELSIUS
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW,
CURRENT_HVAC_COOL,
... |
import os
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 .locks import SerializableLock, ensure_lock
from .store import open_backend_dataset_sto... |
import logging
import pytest_bdd as bdd
bdd.scenarios('prompts.feature')
@bdd.when("I load an SSL page")
def load_ssl_page(quteproc, ssl_server):
# We don't wait here as we can get an SSL question.
quteproc.open_path('/', port=ssl_server.port, https=True, wait=False,
new_tab=True)
@... |
import pytest
from homeassistant.components.huawei_lte import sensor
from homeassistant.const import (
SIGNAL_STRENGTH_DECIBELS,
SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
)
@pytest.mark.parametrize(
("value", "expected"),
(
("-71 dBm", (-71, SIGNAL_STRENGTH_DECIBELS_MILLIWATT)),
("15dB", (... |
import numpy as np
import unittest
from chainercv.utils import assert_is_bbox
from chainercv.utils import testing
@testing.parameterize(
{
'tl': np.random.uniform(-1, 1, size=(10, 2)).astype(np.float32),
'hw': np.random.uniform(0.1, 1, size=(10, 2)).astype(np.float32),
'valid': True},
... |
from gi.repository import GObject, Gtk, GtkSource, Pango
from meld.conf import _
from meld.ui.bufferselectors import EncodingSelector, SourceLangSelector
class MeldStatusMenuButton(Gtk.MenuButton):
"""Compact menu button with arrow indicator for use in a status bar
Implementation based on gedit-status-menu... |
import voluptuous as vol
from homeassistant.components.device_automation import TRIGGER_BASE_SCHEMA
from homeassistant.components.device_automation.exceptions import (
InvalidDeviceAutomationConfig,
)
from homeassistant.components.homeassistant.triggers import event as event_trigger
from homeassistant.const impor... |
import asyncio
from datetime import timedelta
import logging
from aio_georss_gdacs import GdacsFeedManager
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT
from homeassistant.const import (
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_RADIUS,
CONF_SCAN_INTERVAL,
CONF_UNIT_SY... |
import pytest
from unittest.mock import MagicMock
from yandextank.plugins.ShellExec import Plugin
def test_plugin_execute():
plugin = Plugin(MagicMock(), {}, 'shellexec')
assert plugin.execute('echo foo') == 0
def test_plugin_execute_raises():
plugin = Plugin(MagicMock(), {}, 'shellexec')
with pyte... |
from homeassistant.components.gios.const import DOMAIN
from homeassistant.config_entries import (
ENTRY_STATE_LOADED,
ENTRY_STATE_NOT_LOADED,
ENTRY_STATE_SETUP_RETRY,
)
from homeassistant.const import STATE_UNAVAILABLE
from tests.async_mock import patch
from tests.common import MockConfigEntry
from tests.... |
import os
from unittest import mock
import pytest
import lxml.html
from nikola import metadata_extractors
from nikola.plugins.task.sitemap import get_base_path as sitemap_get_base_path
from nikola.post import get_meta
from nikola.utils import (
TemplateHookRegistry,
TranslatableSetting,
demote_headers,
... |
import numpy as np
import matplotlib.pyplot as plt
import mne
from mne.decoding import ReceptiveField, TimeDelayingRidge
from scipy.stats import multivariate_normal
from scipy.io import loadmat
from sklearn.preprocessing import scale
rng = np.random.RandomState(1337) # To make this example reproducible
###########... |
from python_awair.exceptions import AuthError, AwairError
from homeassistant import data_entry_flow
from homeassistant.components.awair.const import DOMAIN
from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_USER
from homeassistant.const import CONF_ACCESS_TOKEN
from .const import CONFIG, DEVICES_FIXTURE,... |
import voluptuous as vol
from homeassistant.const import CONF_PLATFORM
from homeassistant.core import HassJob, callback
from homeassistant.helpers import config_validation as cv
# mypy: allow-untyped-defs
CONF_EVENT_TYPE = "event_type"
CONF_EVENT_DATA = "event_data"
CONF_EVENT_CONTEXT = "context"
TRIGGER_SCHEMA = ... |
import pytest
from tests.async_mock import AsyncMock, patch
from tests.components.nws.const import DEFAULT_FORECAST, DEFAULT_OBSERVATION
@pytest.fixture()
def mock_simple_nws():
"""Mock pynws SimpleNWS with default values."""
with patch("homeassistant.components.nws.SimpleNWS") as mock_nws:
instance... |
import argparse
import logging
import time
from kalliope.core import Utils
from kalliope.core.ConfigurationManager import SettingLoader
from kalliope.core.ConfigurationManager.BrainLoader import BrainLoader
from kalliope.core.SignalLauncher import SignalLauncher
from flask import Flask
from kalliope.core.RestAPI.Fla... |
from collections import OrderedDict
import yaml
from .objects import NodeListClass
# mypy: allow-untyped-calls, no-warn-return-any
def dump(_dict: dict) -> str:
"""Dump YAML to a string and remove null."""
return yaml.safe_dump(
_dict, default_flow_style=False, allow_unicode=True, sort_keys=False
... |
import logging
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import (
async_dispatcher_connect,
async_dispatcher_send,
)
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.event import async_call_later
from .const import (
CONF_SERVER_IDENTIFIER,
... |
import asyncio
import json
import logging
import os
import sys
import re
from copy import deepcopy
from pathlib import Path
from typing import Dict, Any, Optional, Union
import appdirs
import click
from redbot.core.cli import confirm
from redbot.core.utils._internal_utils import safe_delete, create_backup as red_cre... |
from homeassistant.components.camera import SUPPORT_STREAM
from homeassistant.components.mjpeg.camera import (
CONF_MJPEG_URL,
CONF_STILL_IMAGE_URL,
MjpegCamera,
filter_urllib3_logging,
)
from homeassistant.const import (
CONF_AUTHENTICATION,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CON... |
import pytest
from lemur.tests.vectors import (
SAN_CERT,
SAN_CERT_STR,
INTERMEDIATE_CERT,
ROOTCA_CERT,
EC_CERT_EXAMPLE,
ECDSA_PRIME256V1_CERT,
ECDSA_SECP384r1_CERT,
ECDSA_SECP384r1_CERT_STR,
DSA_CERT,
CERT_CHAIN_PKCS7_PEM
)
def test_get_key_type_from_ec_curve():
from lem... |
import mock
from pytest import raises
from paasta_tools.cli.cmds import performance_check
@mock.patch(
"paasta_tools.cli.cmds.performance_check.validate_service_name", autospec=True
)
@mock.patch("requests.post", autospec=True)
@mock.patch(
"paasta_tools.cli.cmds.performance_check.load_performance_check_con... |
from datetime import timedelta
import logging
from prayer_times_calculator import PrayerTimesCalculator, exceptions
from requests.exceptions import ConnectionError as ConnError
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT
from homeassistant.exceptions import ConfigEntryNotReady
fro... |
from django.utils.translation import gettext_lazy as _
from cms.app_base import CMSApp
class CatalogListCMSApp(CMSApp):
name = _("Catalog List")
def get_urls(self, page=None, language=None, **kwargs):
raise NotImplementedError("{} must implement method `.get_urls()`.".format(self.__class__))
clas... |
import json
import logging
import os
import sys
import pandas as pd
from datetime import timedelta, datetime
import io
from collections import defaultdict
from ...common.interfaces import AbstractPlugin, AggregateResultListener
logger = logging.getLogger(__name__) # pylint: disable=C0103
def calc_overall_times(o... |
from functools import partial
from ...utils import verbose, get_config
from ..utils import (has_dataset, _data_path, _data_path_doc,
_get_version, _version_doc)
has_testing_data = partial(has_dataset, name='testing')
@verbose
def data_path(path=None, force_update=False, update_path=True,
... |
import unittest
from unit_tests.myStringIO import StringIO
class TestTrashPutIssueMessage(unittest.TestCase):
def setUp(self):
self.out = StringIO()
def test_trash_put_last_line(self):
from trashcli.put import TrashPutCmd
cmd = TrashPutCmd(self.out,
Strin... |
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_GAS,
DEVICE_CLASS_MOISTURE,
DEVICE_CLASS_OPENING,
DEVICE_CLASS_PROBLEM,
DEVICE_CLASS_SMOKE,
DEVICE_CLASS_VIBRATION,
BinarySensorEntity,
)
from .entity import (
BlockAttributeDescription,
ShellyBlockAttributeEntity,
... |
import logging
import os
import socket
from docopt import docopt
import tinychain as t
logging.basicConfig(
level=getattr(logging, os.environ.get('TC_LOG_LEVEL', 'INFO')),
format='[%(asctime)s][%(module)s:%(lineno)d] %(levelname)s %(message)s')
logger = logging.getLogger(__name__)
def main(args):
arg... |
import warnings
import numpy as np
import six
from .._externals.ppca import PPCA
from .._shared.helpers import get_type
def format_data(x, vectorizer='CountVectorizer',
semantic='LatentDirichletAllocation', corpus='wiki', ppca=True, text_align='hyper'):
"""
Formats data into a list of numpy... |
import numpy as np
import pytest
from tensornetwork.block_sparse.charge import (U1Charge, charge_equal,
BaseCharge)
from tensornetwork.block_sparse.index import Index
from tensornetwork.block_sparse.blocksparsetensor import BlockSparseTensor
from tensornetwork.block_spars... |
import psutil
import time
import netifaces
class NetIOCounters(object):
def __init__(self, pernic=True):
self.last_req = None
self.last_req_time = None
self.pernic = pernic
def _get_net_io_counters(self):
"""
Fetch io counters from psutil and transform it to
d... |
import logging
import multiprocessing
import os
import signal
import sys
import time
try:
from setproctitle import getproctitle, setproctitle
except ImportError:
setproctitle = None
# Path Fix
sys.path.append(
os.path.abspath(
os.path.join(
os.path.dirname(__file__), "../")))
from di... |
import json
import logging
from absl import flags
from perfkitbenchmarker import errors
from perfkitbenchmarker import managed_memory_store
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers import gcp
from perfkitbenchmarker.providers.gcp import util
FLAGS = flags.FLAGS
STANDARD_TIER = 'STANDAR... |
from datetime import timedelta
import pytest
from homeassistant.components import no_ip
from homeassistant.setup import async_setup_component
from homeassistant.util.dt import utcnow
from tests.common import async_fire_time_changed
DOMAIN = "test.example.com"
PASSWORD = "xyz789"
UPDATE_URL = no_ip.UPDATE_URL
US... |
from typing import Any, Dict
import aiohomekit
from aiohomekit.model import Accessory
from aiohomekit.model.characteristics import (
Characteristic,
CharacteristicPermissions,
CharacteristicsTypes,
)
from aiohomekit.model.services import Service, ServicesTypes
from homeassistant.components import zerocon... |
from django.db import migrations
def migrate_componentlist(apps, schema_editor):
Group = apps.get_model("weblate_auth", "Group")
db_alias = schema_editor.connection.alias
groups = Group.objects.using(db_alias).filter(componentlist__isnull=False)
for group in groups:
group.componentlists.add(g... |
from typing import Any, Dict
import aiodns
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.helpers.typing import HomeAssistantType
from .const import SRV_RECORD_PREFIX
async def async_check_srv_record(hass: HomeAssistantType, host: str) -> Dict[str, Any]:
"""Check if the given host is ... |
from homeassistant.components.flo.const import DOMAIN as FLO_DOMAIN
from homeassistant.const import ATTR_ENTITY_ID, CONF_PASSWORD, CONF_USERNAME
from homeassistant.setup import async_setup_component
from .common import TEST_PASSWORD, TEST_USER_ID
async def test_sensors(hass, config_entry, aioclient_mock_fixture):
... |
import logging
import RFXtrx as rfxtrxmod
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_MOTION,
DEVICE_CLASS_SMOKE,
BinarySensorEntity,
)
from homeassistant.const import (
CONF_COMMAND_OFF,
CONF_COMMAND_ON,
CONF_DEVICE_CLASS,
CONF_DEVICES,
STATE_ON,
)
from homeassi... |
import os.path as op
import inspect
from mne.utils import run_tests_if_main
from mne.io import read_raw_nicolet
from mne.io.tests.test_raw import _test_raw_reader
FILE = inspect.getfile(inspect.currentframe())
base_dir = op.join(op.dirname(op.abspath(FILE)), 'data')
fname = op.join(base_dir, 'test_nicolet_raw.data')... |
import os
import os.path
import sys
import time
import shutil
import plistlib
import subprocess
import argparse
import tarfile
import tempfile
import collections
import re
try:
import winreg
except ImportError:
pass
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir,
... |
from homeassistant.components.homeassistant import (
DOMAIN as HA_DOMAIN,
SERVICE_UPDATE_ENTITY,
)
from homeassistant.components.smart_meter_texas.const import (
ELECTRIC_METER,
ESIID,
METER_NUMBER,
)
from homeassistant.const import ATTR_ENTITY_ID, CONF_ADDRESS
from homeassistant.setup import async... |
import unittest
import numpy as np
from chainer import testing
from chainercv.transforms import random_crop
class TestRandomCrop(unittest.TestCase):
def test_random_crop(self):
img = np.random.uniform(size=(3, 48, 32))
out, param = random_crop(img, (48, 32), return_param=True)
y_slice... |
import logging
from pyqvrpro.client import QVRResponseError
from homeassistant.components.camera import Camera
from .const import DOMAIN, SHORT_NAME
_LOGGER = logging.getLogger(__name__)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the QVR Pro camera platform."""
if disc... |
from datetime import datetime, timezone
from typing import Optional, Union
import discord
from redbot.core import checks, commands, modlog
from redbot.core.bot import Red
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils.chat_formatting import box
from redbot.core.utils.menus import DEFAULT_C... |
import datetime
import logging
import os
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import DATA_MEGABYTES
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.reload import se... |
import errno
from functools import partial
import logging
import socket
import broadlink as blk
from broadlink.exceptions import (
AuthenticationError,
BroadlinkException,
NetworkTimeoutError,
)
import voluptuous as vol
from homeassistant import config_entries, data_entry_flow
from homeassistant.const im... |
import diamond.collector
import time
import os
try:
import redis
except ImportError:
redis = None
SOCKET_PREFIX = 'unix:'
SOCKET_PREFIX_LEN = len(SOCKET_PREFIX)
class RedisCollector(diamond.collector.Collector):
_DATABASE_COUNT = 16
_DEFAULT_DB = 0
_DEFAULT_HOST = 'localhost'
_DEFAULT_POR... |
import sys
import textwrap
import cherrypy
from cherrypy.test import helper
class ParamsTest(helper.CPWebCase):
@staticmethod
def setup_server():
class Root:
@cherrypy.expose
@cherrypy.tools.json_out()
@cherrypy.tools.params()
def resource(self, limit=... |
import warnings
from importlib import import_module
from django.core.exceptions import ImproperlyConfigured
from zinnia.settings import URL_SHORTENER_BACKEND
from zinnia.url_shortener.backends.default import backend as default_backend
def get_url_shortener():
"""
Return the selected URL shortener backend.
... |
import pandas as pd
import numpy as np
from scattertext.termranking import AbsoluteFrequencyRanker
from scattertext.termsignificance.LogOddsRatioInformativeDirichletPiror import LogOddsRatioInformativeDirichletPrior
class PriorFactory(object):
def __init__(self,
term_doc_mat,
category=N... |
import tensorflow as tf
from keras import backend as K
from keras.engine import Layer
class AttentionLayer(Layer):
"""
Layer that compute attention for BiMPM model.
For detailed information, see Bilateral Multi-Perspective Matching for
Natural Language Sentences, section 3.2.
Reference:
htt... |
import glob
import os
import sys
from nikola.plugin_categories import PostScanner
from nikola import utils
from nikola.post import Post
LOGGER = utils.get_logger('scan_posts')
class ScanPosts(PostScanner):
"""Scan posts in the site."""
name = "scan_posts"
def scan(self):
"""Create list of pos... |
from binascii import Error as HexError, unhexlify
from typing import Dict
from pyinsteon.address import Address
from pyinsteon.constants import HC_LOOKUP
import voluptuous as vol
from homeassistant.const import (
CONF_ADDRESS,
CONF_DEVICE,
CONF_ENTITY_ID,
CONF_HOST,
CONF_PASSWORD,
CONF_PLATFO... |
import json
import logging
from perfkitbenchmarker import vm_util
# Default configuration for action status polling.
DEFAULT_ACTION_WAIT_SECONDS = 10
DEFAULT_ACTION_MAX_TRIES = 90
def DoctlAndParse(arg_list):
"""Run a doctl command and parse the output.
Args:
arg_list: a list of arguments for doctl. Will ... |
import asyncio
import logging
import voluptuous as vol
import xs1_api_client
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_PORT,
CONF_SSL,
CONF_USERNAME,
)
from homeassistant.helpers import discovery
import homeassistant.helpers.config_validation as cv
from homeassistant.helper... |
import unittest
import pandas as pd
import numpy as np
from pgmpy.estimators import HillClimbSearch, K2Score
from pgmpy.models import BayesianModel
class TestHillClimbEstimator(unittest.TestCase):
def setUp(self):
self.rand_data = pd.DataFrame(
np.random.randint(0, 5, size=(int(1e4), 2)), c... |
import asyncio
from collections import OrderedDict
import logging
from typing import Any, Dict, List, Optional
import attr
import voluptuous as vol
from homeassistant.const import CONF_EXCLUDE, CONF_INCLUDE
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import ServiceNotFound
fr... |
from babelfish import Language
import os
import pytest
from subliminal.providers.argenteam import ArgenteamSubtitle, ArgenteamProvider
from vcr import VCR
vcr = VCR(path_transformer=lambda path: path + '.yaml',
record_mode=os.environ.get('VCR_RECORD_MODE', 'once'),
match_on=['method', 'scheme', 'h... |
from datetime import timedelta
import logging
from homeassistant.components.climate import (
DOMAIN as SENSOR_DOMAIN,
ENTITY_ID_FORMAT,
ClimateEntity,
)
from homeassistant.components.climate.const import (
FAN_HIGH,
FAN_LOW,
FAN_MEDIUM,
HVAC_MODE_AUTO,
HVAC_MODE_COOL,
HVAC_MODE_FAN... |
from typing import Dict, List
import voluptuous as vol
from homeassistant.components.device_automation.exceptions import (
InvalidDeviceAutomationConfig,
)
from homeassistant.const import (
ATTR_DEVICE_CLASS,
ATTR_UNIT_OF_MEASUREMENT,
CONF_ABOVE,
CONF_BELOW,
CONF_ENTITY_ID,
CONF_TYPE,
... |
from datetime import datetime as dt, timedelta as dtd
import bson
import numpy as np
import pytest
from mock import patch
from pymongo.server_type import SERVER_TYPE
from arctic._config import FwPointersCfg, FW_POINTERS_REFS_KEY
from arctic._util import mongo_count
from arctic.store._ndarray_store import NdarrayStor... |
import unittest
import numpy as np
from chainercv.transforms import random_expand
from chainercv.utils import testing
@testing.parameterize(
{'max_ratio': 1},
{'max_ratio': 4},
)
class TestRandomExpand(unittest.TestCase):
def test_random_expand(self):
img = np.random.uniform(-1, 1, size=(3, 64... |
import os.path as op
import pytest
import numpy as np
from numpy.testing import assert_array_almost_equal, assert_allclose
import mne
from mne.datasets import testing
from mne import (read_cov, read_forward_solution, read_evokeds,
convert_forward_solution, VectorSourceEstimate)
from mne.cov import r... |
import logging
import unittest
import numpy as np
from gensim.models.keyedvectors import KeyedVectors, REAL, pseudorandom_weak_vector
from gensim.test.utils import datapath
import gensim.models.keyedvectors
logger = logging.getLogger(__name__)
class TestKeyedVectors(unittest.TestCase):
def setUp(self):
... |
import asyncio
import logging
from types import MappingProxyType
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import ATTR_ENTITY_ID
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
from . import (
ATTR_OPTION,
ATTR_OPTIONS,
... |
import re
from reparser import Parser, Token, MatchGroup
from hangups import hangouts_pb2
# Common regex patterns
BOUNDARY_CHARS = r'\s`!()\[\]{{}};:\'".,<>?«»“”‘’*_~='
B_LEFT = r'(?:(?<=[' + BOUNDARY_CHARS + r'])|(?<=^))' # Lookbehind
B_RIGHT = r'(?:(?=[' + BOUNDARY_CHARS + r'])|(?=$))' # Lookahead
# Regex pa... |
import numpy as np
import spacy
from sklearn.linear_model import LogisticRegression
from scattertext import SampleCorpora, produce_scattertext_explorer
from scattertext.CorpusFromPandas import CorpusFromPandas
nlp = spacy.load('en')
convention_df = SampleCorpora.ConventionData2012.get_data()
corpus = CorpusFromPanda... |
import voluptuous as vol
from homeassistant.components import mysensors
from homeassistant.components.switch import DOMAIN, SwitchEntity
from homeassistant.const import ATTR_ENTITY_ID, STATE_OFF, STATE_ON
import homeassistant.helpers.config_validation as cv
from .const import DOMAIN as MYSENSORS_DOMAIN, SERVICE_SEND... |
from datetime import datetime as dt
import numpy as np
import pandas as pd
import pytest
from mock import create_autospec, sentinel, call
from pymongo import ReadPreference
from pymongo.collection import Collection
from arctic._compression import decompress
from arctic.date import CLOSED_OPEN
from arctic.date._dater... |
from argparse import ArgumentTypeError
import mock
from pytest import raises
from paasta_tools.cli.cmds import secret
def test_add_subparser():
mock_subparsers = mock.Mock()
secret.add_subparser(mock_subparsers)
assert mock_subparsers.add_parser.called
mock_subparsers.add_parser.return_value.set_de... |
import pytest
import sh
from molecule import config
from molecule.verifier.lint import flake8
@pytest.fixture
def _patched_get_tests(mocker):
m = mocker.patch('molecule.verifier.lint.flake8.Flake8._get_tests')
m.return_value = ['test1', 'test2', 'test3']
return m
@pytest.fixture
def _verifier_lint_se... |
import json
import time
from homeassistant import config_entries, setup
from homeassistant.components.flo.const import DOMAIN
from homeassistant.const import CONTENT_TYPE_JSON
from .common import TEST_EMAIL_ADDRESS, TEST_PASSWORD, TEST_TOKEN, TEST_USER_ID
from tests.async_mock import patch
async def test_form(has... |
from http import client
from radicale.log import logger
NOT_ALLOWED = (
client.FORBIDDEN, (("Content-Type", "text/plain"),),
"Access to the requested resource forbidden.")
FORBIDDEN = (
client.FORBIDDEN, (("Content-Type", "text/plain"),),
"Action on the requested resource refused.")
BAD_REQUEST = (
... |
import json
import unittest
import mock
from httpretty import httpretty
from kalliope.core.NeuronModule import NeuronModule, InvalidParameterException
from kalliope.neurons.uri.uri import Uri
class TestUri(unittest.TestCase):
def setUp(self):
self.test_url = "http://kalliope.fr/voices/"
def testG... |
from datetime import timedelta
import logging
from homeassistant.components.weather import (
ATTR_CONDITION_CLEAR_NIGHT,
ATTR_CONDITION_SUNNY,
ATTR_FORECAST_CONDITION,
ATTR_FORECAST_PRECIPITATION_PROBABILITY,
ATTR_FORECAST_TEMP,
ATTR_FORECAST_TIME,
ATTR_FORECAST_WIND_BEARING,
ATTR_FORE... |
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import matplotlib.pyplot as plt
from numpy.random import randn
import numpy as np
from filterpy.memory import FadingMemoryFilter
from filterpy.gh import GHKFilter
def dotest_2d_data():
""" tests having ... |
from __future__ import print_function
import os
import sys
import fileinput
import argparse
def main(args):
ap = argparse.ArgumentParser()
ap.add_argument('files', nargs='*', help='files to unique (must be sorted first)')
ns = ap.parse_args(args)
def _print(lines):
if lines is not None:
... |
import logging
from typing import Optional, Tuple
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW,
CURRENT_HVAC_COOL,
CURRENT_HVAC_FAN,
CURRENT_HVAC_HEAT,
CURRENT_HVAC_IDLE,
CURRENT_... |
import time
from test import unittest
from mock import Mock
from mock import patch
from mock import call
import configobj
import diamond.handler.graphite as mod
from diamond.metric import Metric
# These two methods are used for overriding the GraphiteHandler._connect method.
# Please check the Test class' setUp a... |
import asyncio
import logging
import aiohttp
import async_timeout
import voluptuous as vol
from homeassistant.components.tts import CONF_LANG, PLATFORM_SCHEMA, Provider
from homeassistant.const import CONF_API_KEY, HTTP_OK
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.... |
INLINESTYLES = False
try:
import locale
locale.setlocale(locale.LC_ALL, '')
except:
pass
# set up Pygments
from pygments.formatters import LatexFormatter
# The default formatter
DEFAULT = LatexFormatter()
# Add name -> formatter pairs for every variant you want to use
VARIANTS = {
# 'linenos': Ht... |
from typing import Sequence
from PyQt5.QtNetwork import QNetworkCookie, QNetworkCookieJar
from PyQt5.QtCore import pyqtSignal, QDateTime
from qutebrowser.config import config
from qutebrowser.utils import utils, standarddir, objreg, log
from qutebrowser.misc import lineparser, objects
cookie_jar = None
ram_cookie_... |
from ast import literal_eval
from itertools import chain
from itertools import islice
from . import nodes
from .compiler import CodeGenerator
from .compiler import has_safe_repr
from .environment import Environment
from .environment import Template
def native_concat(nodes):
"""Return a native Python type from t... |
from unittest.mock import Mock, patch
from kombu import transport
class test_supports_librabbitmq:
def test_eventlet(self):
with patch('kombu.transport._detect_environment') as de:
de.return_value = 'eventlet'
assert not transport.supports_librabbitmq()
class test_transport:
... |
from __future__ import division
import numpy as np
import chainer
from chainer.backends import cuda
import chainer.functions as F
from chainer import initializers
import chainer.links as L
from chainercv.links.model.fpn.misc import argsort
from chainercv.links.model.fpn.misc import choice
from chainercv.links.model... |
from urllib.request import urlopen
import socket
from contextlib import contextmanager
import vcr
@contextmanager
def overridden_dns(overrides):
"""
Monkeypatch socket.getaddrinfo() to override DNS lookups (name will resolve
to address)
"""
real_getaddrinfo = socket.getaddrinfo
def fake_geta... |
import logging
import vlc
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
MEDIA_TYPE_MUSIC,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PLAY_MEDIA,
SUPPORT_STOP,
SUPPORT_VOLUME_MUT... |
import logging
import sys
from setuptools import find_packages
from setuptools import setup
from setuptools.command.test import test as TestCommand
long_description = open('README.md').read()
changelog = open('CHANGES.md').read()
class PyTest(TestCommand):
user_options = [('pytest-args=', 'a', "Arguments to pa... |
import pytest
def pytest_addoption(parser):
parser.addoption("-E", action="append", metavar="NAME",
help="only run tests matching the environment NAME.")
def pytest_configure(config):
# register an additional marker
config.addinivalue_line("markers",
"env(name): mark test to run only on na... |
from datetime import timedelta
from io import BytesIO
import av
import pytest
from homeassistant.components.stream.core import Segment
from homeassistant.components.stream.recorder import recorder_save_worker
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.as... |
from typing import Dict, List
import voluptuous as vol
from homeassistant.components.device_automation import toggle_entity
from homeassistant.const import CONF_DOMAIN
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.condition import ConditionCheckerType
from homeassistant.helpers.ty... |
from django.http import Http404
from django.template.defaultfilters import slugify
from django.utils.translation import gettext as _
from django.views.generic.list import BaseListView
from django.views.generic.list import ListView
from tagging.models import Tag
from tagging.models import TaggedItem
from tagging.utils... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import six
_PROVIDER_INFO_REGISTRY = {}
def GetProviderInfoClass(cloud):
"""Returns the provider info class corresponding to the cloud."""
return _PROVIDER_INFO_REGISTRY.get(cloud, BaseProviderInfo)
c... |
from datetime import datetime, timedelta
import logging
from pathlib import Path
from typing import Any, Dict, List, Optional
from aiofreepybox import Freepybox
from aiofreepybox.api.wifi import Wifi
from aiofreepybox.exceptions import HttpRequestError
from homeassistant.config_entries import ConfigEntry
from homeas... |
from datetime import timedelta
import importlib
import logging
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_DISPLAY_OPTIONS,
CONF_NAME,
PRESSURE_HPA,
TEMP_CELSIUS,
VOLT,
)
import homeassistant.helpers.config_validation... |
import unittest
import math
import numpy as np
import pandas as pd
from numpy import testing as np_test
from pgmpy.estimators.CITests import *
np.random.seed(42)
class TestPearsonr(unittest.TestCase):
def setUp(self):
self.df_ind = pd.DataFrame(np.random.randn(10000, 3), columns=["X", "Y", "Z"])
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.