text stringlengths 213 32.3k |
|---|
from __future__ import absolute_import
import logging
import time
from absl import flags
# This is the path that we SCP object_storage_interface to.
from providers import object_storage_interface
from google.cloud import storage
FLAGS = flags.FLAGS
class GcsService(object_storage_interface.ObjectStorageServiceBas... |
import os
import atexit
import subprocess
process = subprocess.Popen(
args=('node', os.path.join(os.path.dirname(__file__), 'test_server.js'),),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT
)
# Ensure the process is killed on exit
atexit.register(lambda _process: _process.kill(), process)
def read_l... |
from unittest import TestCase
from unittest.mock import patch
from httpobs.scanner.utils import valid_hostname
class TestValidHostname(TestCase):
def test_valid_hostname(self):
# TODO: Try to find a site with www.site.foo but not site.foo
self.assertTrue(valid_hostname('mozilla.org'))
se... |
import pytest
from jinja2 import DictLoader
from jinja2 import Environment
from jinja2 import PrefixLoader
from jinja2 import Template
from jinja2 import TemplateAssertionError
from jinja2 import TemplateNotFound
from jinja2 import TemplateSyntaxError
class TestCorner:
def test_assigned_scoping(self, env):
... |
import asyncio
import logging
import voluptuous as vol
from homeassistant import exceptions
from homeassistant.components import websocket_api
from homeassistant.components.websocket_api import const
async def test_send_big_result(hass, websocket_client):
"""Test sending big results over the WS."""
@webso... |
import asyncio
from collections import OrderedDict
import logging
import os
from typing import Dict
import async_timeout
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.core import callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import ... |
import gc
import sys
import weakref
from flexx.util.testing import run_tests_if_main, skipif, skip, raises
from flexx.event.both_tester import run_in_both, this_is_js
from flexx.util.logging import capture_log
from flexx import event
loop = event.loop
logger = event.logger
class Node(event.Component):
val = ... |
from collections import deque
class AssetPriceBuffers(object):
"""
Utility class to store double-ended queue ("deque")
based price buffers for usage in lookback-based
indicator calculations.
Parameters
----------
assets : `list[str]`
The list of assets to create price buffers for... |
import os
from gitless import core
from . import pprint
def parser(subparsers, _):
"""Adds the init parser to the given subparsers object."""
desc = (
'create an empty git repository or clone remote')
init_parser = subparsers.add_parser(
'init', help=desc, description=desc.capitalize(), aliases=[... |
from typing import TYPE_CHECKING, Hashable, Iterable, Optional, Union, overload
from . import duck_array_ops
from .computation import dot
from .options import _get_keep_attrs
from .pycompat import is_duck_dask_array
if TYPE_CHECKING:
from .dataarray import DataArray, Dataset
_WEIGHTED_REDUCE_DOCSTRING_TEMPLATE ... |
from datetime import timedelta
import pytest
from homeassistant.components import google_domains
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"
USERNAME = "abc123"
PASSWORD = "xyz789"
UPDAT... |
import os
import os.path
import zipfile
import logging
import pytest
from PyQt5.QtCore import QUrl
from qutebrowser.components import adblock
from qutebrowser.utils import urlmatch
from helpers import utils
pytestmark = pytest.mark.usefixtures('qapp')
# TODO See ../utils/test_standarddirutils for OSError and cap... |
import fnmatch
from functools import partial
import ipaddress
import logging
import socket
import voluptuous as vol
from zeroconf import (
DNSPointer,
DNSRecord,
Error as ZeroconfError,
InterfaceChoice,
IPVersion,
NonUniqueNameException,
ServiceBrowser,
ServiceInfo,
ServiceStateCha... |
from django.utils.translation import pgettext_lazy
from weblate_language_data import languages
from weblate_language_data.ambiguous import AMBIGUOUS
NO_CODE_LANGUAGES = {lang[0] for lang in languages.LANGUAGES}
UNDERSCORE_EXCEPTIONS = {"nb_NO", "zh_Hant", "zh_Hans", "be_Latn", "ro_MD", "pt_BR"}
AT_EXCEPTIONS = {"ca@... |
from perfkitbenchmarker import linux_packages
DOCKER_RPM_URL = ('https://get.docker.com/rpm/1.7.0/centos-6/'
'RPMS/x86_64/docker-engine-1.7.0-1.el6.x86_64.rpm')
# Docker images that VMs are allowed to install.
_IMAGES = [
'cloudsuite/data-caching:client',
'cloudsuite/data-caching:server',
... |
from collections import OrderedDict
import logging
from life360 import Life360Error, LoginError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from .const import CONF_AUTHORIZATION, DOMAIN
from .helpers import get_api
_LOGGER = logging... |
import logging
import radiotherm
import voluptuous as vol
from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateEntity
from homeassistant.components.climate.const import (
CURRENT_HVAC_COOL,
CURRENT_HVAC_HEAT,
CURRENT_HVAC_IDLE,
FAN_OFF,
FAN_ON,
HVAC_MODE_AUTO,
HVAC_MODE_CO... |
import numpy as np
from matchzoo.engine.base_metric import BaseMetric, sort_and_couple
class Precision(BaseMetric):
"""Precision metric."""
ALIAS = 'precision'
def __init__(self, k: int = 1, threshold: float = 0.):
"""
:class:`PrecisionMetric` constructor.
:param k: Number of ... |
import pytest
from hangups.ui.emoticon import _replace_words, replace_emoticons
@pytest.mark.parametrize('replacements,string,result', [
({}, '', ''),
({}, ' ', ' '),
({}, '\n', '\n'),
({}, 'foo', 'foo'),
({'foo': 'bar'}, 'foo', 'bar'),
({'foo': 'bar'}, 'foofoo', 'foofoo'),
({'foo': 'bar... |
import logging
import boto3
from smart_open import open
#
# These are publicly available via play.min.io
#
KEY_ID = 'Q3AM3UQ867SPQQA43P2F'
SECRET_KEY = 'zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG'
ENDPOINT_URL = 'https://play.min.io:9000'
def read_boto3():
"""Read directly using boto3."""
session = get_minio... |
from typing import Callable, Sequence
from qutebrowser.utils import usertypes
from qutebrowser.misc import objects
DeleteFuncType = Callable[[Sequence[str]], None]
def get_cmd_completions(info, include_hidden, include_aliases, prefix=''):
"""Get a list of completions info for commands, sorted by name.
Ar... |
import logging
import epson_projector as epson
from epson_projector.const import (
BACK,
BUSY,
CMODE,
CMODE_LIST,
CMODE_LIST_SET,
DEFAULT_SOURCES,
EPSON_CODES,
FAST,
INV_SOURCES,
MUTE,
PAUSE,
PLAY,
POWER,
SOURCE,
SOURCE_LIST,
TURN_OFF,
TURN_ON,
V... |
import logging
from aiohomekit.model.characteristics import (
ActivationStateValues,
CharacteristicsTypes,
CurrentHeaterCoolerStateValues,
HeatingCoolingCurrentValues,
HeatingCoolingTargetValues,
SwingModeValues,
TargetHeaterCoolerStateValues,
)
from aiohomekit.utils import clamp_enum_to_c... |
from homeassistant.helpers.entity import Entity
from . import DEFAULT_SCAN_INTERVAL, DOMAIN, timestamp_ms_to_date
from .const import DATA
SCAN_INTERVAL = DEFAULT_SCAN_INTERVAL
ATTR_IBAN = "account"
ATTR_USABLE_BALANCE = "usable_balance"
ATTR_BANK_BALANCE = "bank_balance"
ATTR_ACC_OWNER_TITLE = "owner_title"
ATTR_A... |
import pygogo as gogo
from chardet import detect
from meza.compat import decode
try:
from twisted.internet.protocol import Protocol
except ImportError:
Protocol = object
else:
from twisted.python.reflect import prefixedMethodNames as find_method_names
logger = gogo.Gogo(__name__, monolog=True).logger
#... |
import re
import sys
import os.path
import glob
import subprocess
import tempfile
import argparse
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir,
os.pardir))
from scripts import utils
REPO_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)),
... |
import sys
from django.core.management import ManagementUtility
RESTRICTED_COMMANDS = {"squashmigrations", "makemigrations"}
class WeblateManagementUtility(ManagementUtility):
def __init__(self, argv=None, developer_mode: bool = False):
super().__init__(argv)
self.developer_mode = developer_mod... |
from homeassistant.components.emulated_roku import config_flow
from tests.common import MockConfigEntry
async def test_flow_works(hass):
"""Test that config flow works."""
flow = config_flow.EmulatedRokuFlowHandler()
flow.hass = hass
result = await flow.async_step_user(
user_input={"name": "... |
import logging
import pytest
def command_expansion_base(
quteproc, send_msg, recv_msg, url="data/hello.txt"):
quteproc.open_path(url)
quteproc.send_cmd(':message-info ' + send_msg)
quteproc.mark_expected(category='message',
loglevel=logging.INFO,
... |
import diamond.collector
import re
import os
from collections import defaultdict
_RE = re.compile('|'.join([
r'sockets: used (?P<used>\d+)?',
r'(TCP|TCP6): inuse (?P<tcp_inuse>\d+)' +
r'( orphan (?P<tcp_orphan>\d+) ' +
r'tw (?P<tcp_tw>\d+) ' +
r'alloc (?P<tcp_alloc>\d+) ' +
r'mem (?P<tcp_mem>... |
from aiohttp.test_utils import TestClient
from homeassistant.components.withings import const
from homeassistant.config import async_process_ha_core_config
from homeassistant.const import (
CONF_CLIENT_ID,
CONF_CLIENT_SECRET,
CONF_EXTERNAL_URL,
CONF_UNIT_SYSTEM,
CONF_UNIT_SYSTEM_METRIC,
)
from hom... |
from homeassistant.components.nexia import util
from homeassistant.const import HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_UNAUTHORIZED
async def test_is_invalid_auth_code():
"""Test for invalid auth."""
assert util.is_invalid_auth_code(HTTP_UNAUTHORIZED) is True
assert util.is_invalid_auth_code(HTTP_FORBIDDE... |
import unittest
import mock
from kalliope.core.Models import Singleton
from kalliope.core.Models.settings.Resources import Resources
from kalliope.core.NeuronLauncher import NeuronLauncher, NeuronParameterNotAvailable
from kalliope.core.ConfigurationManager import SettingLoader
from kalliope.core.Models.Neuron impor... |
import time
from six.moves import xrange
import arctic._compression as aclz4
from arctic import Arctic
from arctic.async import ASYNC_ARCTIC, async_arctic_submit, async_wait_requests
from tests.integration.chunkstore.test_utils import create_test_data
a = Arctic('localhost:27017')
library_name = 'asyncbench.test'
... |
import json
import voluptuous as vol
from homeassistant.components import mqtt
from homeassistant.const import CONF_PAYLOAD, CONF_PLATFORM
from homeassistant.core import HassJob, callback
import homeassistant.helpers.config_validation as cv
# mypy: allow-untyped-defs
CONF_ENCODING = "encoding"
CONF_QOS = "qos"
CON... |
from __future__ import print_function
import argparse
import os
import re
import sys
import six
from Crypto.Hash import SHA256
def get_hash(fileobj):
h = SHA256.new()
chunk_size = 8192
while True:
chunk = fileobj.read(chunk_size)
if len(chunk) == 0:
break
h.update(c... |
import pandas as pd
from arctic.store.versioned_item import VersionedItem
def test_versioned_item_str():
item = VersionedItem(symbol="sym",
library="ONEMINUTE",
data=pd.DataFrame(),
version=1.0,
host='myhost',
... |
import voluptuous as vol
from homeassistant.components.http import HomeAssistantView
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_ICON,
ATTR_LOCATION,
ATTR_STATE,
ATTR_UNIT_OF_MEASUREMENT,
CONF_ADDRESS,
CONF_EMAIL,
CONF_ENTITY_ID,
CONF_SENSORS,
CONF_STATE,
CONF_UR... |
import coverage
class Plugin(coverage.CoveragePlugin):
"""A configuring plugin for testing."""
def configure(self, config):
"""Configure all the things!"""
opt_name = "report:exclude_lines"
exclude_lines = config.get_option(opt_name)
exclude_lines.append(r"pragma: custom")
... |
from kombu.pools import producers
from .queues import task_exchange
priority_to_routing_key = {
'high': 'hipri',
'mid': 'midpri',
'low': 'lopri',
}
def send_as_task(connection, fun, args=(), kwargs={}, priority='mid'):
payload = {'fun': fun, 'args': args, 'kwargs': kwargs}
routing_key = priorit... |
import inspect
import os.path
import coverage
from coverage import env
from coverage.context import qualname_from_frame
from coverage.data import CoverageData
from tests.coveragetest import CoverageTest
class StaticContextTest(CoverageTest):
"""Tests of the static context."""
def test_no_context(self):
... |
from __future__ import with_statement
import os
import sys
import logging
import threading
import tempfile
import argparse
try:
import Queue
except ImportError:
import queue as Queue
import Pyro4
from gensim.models import ldamodel
from gensim import utils
logger = logging.getLogger('gensim.models.lda_worker'... |
import logging
import time
import threading as th
import multiprocessing as mp
from queue import Empty, Full
from ...stepper import StpdReader
logger = logging.getLogger(__name__)
class BFGBase(object):
"""
A BFG load generator that manages multiple workers as processes and
threads in each of them and ... |
from functools import partial
from ...utils import verbose
from ..utils import (has_dataset, _data_path, _data_path_doc,
_get_version, _version_doc)
has_multimodal_data = partial(has_dataset, name='multimodal')
@verbose
def data_path(path=None, force_update=False, update_path=True, download=T... |
import pytest
import numpy as np
import os.path as op
from mne import create_info, EvokedArray, events_from_annotations, Epochs
from mne.channels import make_standard_montage
from mne.datasets.testing import data_path, _pytest_param
from mne.preprocessing.nirs import optical_density, beer_lambert_law
from mne.io impo... |
import datetime
from django.test import SimpleTestCase, TestCase
from django.utils import timezone
from weblate.accounts.models import Profile
from weblate.lang.models import Language
from weblate.trans.models import Component, Project, Translation, Unit
from weblate.trans.templatetags.translations import get_locati... |
from Handler import Handler
import logging
import logging.handlers
class ArchiveHandler(Handler):
"""
Implements the Handler abstract class, archiving data to a log file
"""
def __init__(self, config):
"""
Create a new instance of the ArchiveHandler class
"""
# Initia... |
from __future__ import division
import logging
import os
import copy
import multiprocessing
from shutil import copyfile, rmtree
from gensim import utils
from gensim.models.keyedvectors import KeyedVectors
from gensim.scripts.glove2word2vec import glove2word2vec
logger = logging.getLogger(__name__)
class Wordrank... |
from __future__ import division
import numpy as np
import chainer
import chainer.functions as F
import chainer.links as L
from chainercv.transforms import resize
from chainercv import utils
class SegNetBasic(chainer.Chain):
"""SegNet Basic for semantic segmentation.
This is a SegNet [#]_ model for seman... |
import unittest
from credstash import expand_wildcard
class TestExpandingWildcard(unittest.TestCase):
secrets_set = ["a", "b", "ab", " a", " b",
"ba", "abc", "a[anyvalue]z", "a b", "aabb"]
secrets_set2 = ["QQQ", "QVQQ", "QVQVQ",
"QQ", "Q", "QQVQ", "QrEQrE", "QErQE"]
... |
from Handler import Handler
import logging
from collections import deque
try:
import dogapi
except ImportError:
dogapi = None
class DatadogHandler(Handler):
def __init__(self, config=None):
"""
New instance of DatadogHandler class
"""
Handler.__init__(self, config)
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import json
import logging
import time
from perfkitbenchmarker import resource
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers.aws import util
# https://docs.aws.amazon.com/IAM/lates... |
import uuid
from collections import OrderedDict
from functools import lru_cache, partial
from html import escape
import pkg_resources
from .formatting import inline_variable_array_repr, short_data_repr
STATIC_FILES = ("static/html/icons-svg-inline.html", "static/css/style.css")
@lru_cache(None)
def _load_static_f... |
import os
import re
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
def test_hostname(host):
assert re.search(r'instance-[12]', host.check_output('hostname -s'))
def test_etc_molecule_directory(h... |
import glob
import logging
import os
import shutil
import stat
import time
from configparser import RawConfigParser, MissingSectionHeaderError
from multiprocessing import Event as ProcessEvent
from threading import Event as ThreadEvent
import yaml
from pkg_resources import resource_filename
from yandextank.common.in... |
import mock
from paasta_tools import paasta_maintenance
@mock.patch("paasta_tools.mesos_maintenance.is_host_drained", autospec=True)
@mock.patch(
"paasta_tools.mesos_maintenance.get_hosts_past_maintenance_start", autospec=True
)
def test_is_safe_to_kill(mock_get_hosts_past_maintenance_start, mock_is_host_draine... |
import mne
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__, usage='usage: %prog fname [fname2 ...]')
options, args = parser.parse_args()
for arg in args:
print(mne.what(arg))
mne.utils.run_command_if_main()
|
from decimal import Decimal
from django.core.exceptions import ValidationError
from django import forms
from django.db import models
from django.utils.html import format_html
from django.utils.translation import gettext_lazy as _
from shop.conf import app_settings
from shop.money.iso4217 import CURRENCIES
from shop.... |
from distutils.core import setup
import sys
def main():
sys.path.append('.')
from trashcli import trash
scripts.add_script('trash' , 'trashcli.put' , 'main')
scripts.add_script('trash-put' , 'trashcli.put' , 'main')
scripts.add_script('trash-list' , 'trashcli.list', 'main')
scripts... |
import logging
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_STATE,
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_TEMPERATURE,
)
from homeassistant.helpers.dispatcher import async_dispatcher_send
from homeassistant.util import decorator
from .const import CONF_INVERSE, SIGNAL_DS18B20_NEW
_LOGGER = lo... |
import posixpath
from absl import flags
from perfkitbenchmarker.linux_packages import cuda_toolkit
flags.DEFINE_string('mx_version', '1.4.0', 'mxnet pip package version')
FLAGS = flags.FLAGS
def GetEnvironmentVars(vm):
"""Return a string containing MXNet-related environment variables.
Args:
vm: vm to get ... |
import json
from homeassistant.components.nut.const import DOMAIN
from homeassistant.const import CONF_HOST, CONF_PORT, CONF_RESOURCES
from homeassistant.core import HomeAssistant
from tests.async_mock import MagicMock, patch
from tests.common import MockConfigEntry, load_fixture
def _get_mock_pynutclient(list_var... |
from collections import defaultdict
import itertools
from ..exceptions import ParseError
from ..lexer import Token
from ..tree import Tree
from ..grammar import Terminal as T, NonTerminal as NT, Symbol
try:
xrange
except NameError:
xrange = range
def match(t, s):
assert isinstance(t, T)
return t.nam... |
import numpy as np
from .utils import is_duck_array
integer_types = (int, np.integer)
try:
import dask.array
from dask.base import is_dask_collection
# solely for isinstance checks
dask_array_type = (dask.array.Array,)
def is_duck_dask_array(x):
return is_duck_array(x) and is_dask_coll... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import patch
from diamond.collector import Collector
from onewire import OneWireCollector
###############################################################################
class TestOneWireCollector(Collector... |
from __future__ import absolute_import, print_function
import sys
from unittest import TestCase, main
from lark import Lark
from lark.tree import Tree
from lark.tools import standalone
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
class TestStandalone(TestCase):
def ... |
from filterpy.discrete_bayes import predict, update, normalize
from numpy.random import randn, randint
import numpy as np
def _predict(distribution, offset, kernel):
""" explicit convolution with wraparound"""
N = len(distribution)
kN = len(kernel)
width = int((kN - 1) / 2)
prior = np.zeros(N)
... |
import pytest
from qutebrowser.misc import objects
from qutebrowser.commands import runners, cmdexc
class TestCommandParser:
def test_parse_all(self, cmdline_test):
"""Test parsing of commands.
See https://github.com/qutebrowser/qutebrowser/issues/615
Args:
cmdline_test: A... |
import logging
from pymediaroom import (
COMMANDS,
PyMediaroomError,
Remote,
State,
install_mediaroom_protocol,
)
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
MEDIA_TYPE_... |
from collections import namedtuple
import logging
from tellcore import telldus
import tellcore.constants as tellcore_constants
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_ID,
CONF_NAME,
CONF_PROTOCOL,
PERCENTAGE,
TEMP... |
from collections import Counter
from flashtext import KeywordProcessor
import scattertext as st
class FlashTextExtact(st.FeatsFromSpacyDoc):
'''
'''
def set_keyword_processor(self, keyword_processor):
'''
:param keyword_processor: set, phrases to look for
:return: self
'... |
import flask
from docker_registry.core import compat
from docker_registry.core import exceptions
json = compat.json
from . import storage
from . import toolkit
from .lib import mirroring
from .lib import signals
from .app import app # noqa
store = storage.load()
"""Those routes are loaded only when `standalone'... |
from copy import deepcopy
from homeassistant.components.deconz.const import (
CONF_ALLOW_CLIP_SENSOR,
DOMAIN as DECONZ_DOMAIN,
)
from homeassistant.components.deconz.gateway import get_gateway_from_config_entry
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.const import... |
import logging
from urllib.parse import urlparse
from synology_dsm import SynologyDSM
from synology_dsm.exceptions import (
SynologyDSMException,
SynologyDSMLogin2SAFailedException,
SynologyDSMLogin2SARequiredException,
SynologyDSMLoginInvalidException,
SynologyDSMRequestException,
)
import volupt... |
import numpy as np
import os
from chainercv.chainer_experimental.datasets.sliceable import GetterDataset
from chainercv.datasets.voc import voc_utils
from chainercv.utils import read_image
from chainercv.utils import read_label
class VOCSemanticSegmentationDataset(GetterDataset):
"""Semantic segmentation datas... |
from datetime import timedelta
import logging
import urllib
from pyW215.pyW215 import SmartPlug
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
from homeassistant.const import (
ATTR_TEMPERATURE,
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_USERNAME... |
import os
import shutil
import tempfile
from trashcli.list import ListCmd
from .files import (require_empty_dir, make_sticky_dir, make_unsticky_dir)
from .output_collector import OutputCollector
from .fake_trash_dir import (
a_trashinfo_without_date,
a_trashinfo_without_path,
a_trashinfo_with_invalid_date... |
from collections import OrderedDict
import voluptuous as vol
from homeassistant import config_entries
from .const import (
CONF_NETWORK_KEY,
CONF_USB_STICK_PATH,
DEFAULT_CONF_USB_STICK_PATH,
DOMAIN,
)
@config_entries.HANDLERS.register(DOMAIN)
class ZwaveFlowHandler(config_entries.ConfigFlow):
... |
import pytest
from unittest.mock import Mock
from kombu import Connection, Exchange, Queue
class SimpleBase:
def Queue(self, name, *args, **kwargs):
q = name
if not isinstance(q, Queue):
q = self.__class__.__name__
if name:
q = f'{q}.{name}'
retu... |
from django.conf import settings
from django.contrib.auth import get_user_model, authenticate, login, password_validation
from django.contrib.auth.forms import PasswordResetForm
from django.contrib.sites.shortcuts import get_current_site
from django.core.mail import EmailMultiAlternatives
from django.core.exceptions i... |
from datetime import timedelta
import logging
from typing import Any, Callable, Dict, List, Optional
from bsblan import BSBLan, BSBLanError, Info, State
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
ATTR_HVAC_MODE,
ATTR_PRESET_MODE,
HVAC_M... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import Mock
from mock import patch
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
from diamond.collector import Collector
from slabinfo import SlabInfoCollector
... |
from paasta_tools.frameworks.native_scheduler import MESOS_TASK_SPACER
from paasta_tools.mesos_tools import status_mesos_tasks_verbose
from paasta_tools.utils import calculate_tail_lines
from paasta_tools.utils import compose_job_id
def perform_command(command, service, instance, cluster, verbose, soa_dir):
tail... |
import pytest
from decouple import Choices
FRUIT_APPLE = 'apple'
FRUIT_BANANA = 'banana'
FRUIT_COCONUT = 'coconut'
ALLOWED_FRUITS = (
(FRUIT_APPLE, 'Apple'),
(FRUIT_BANANA, 'Banana'),
(FRUIT_COCONUT, 'Coconut'),
)
ZERO = 0
THREE = 3
SEVEN = 7
ALLOWED_NUMBERS = (
(ZERO, 'Zero'),... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from tensorflow.python.ops import control_flow_ops
def apply_with_random_selector(x, func, num_cases):
"""Computes func(x, sel), with sel sampled from [0...num_cases-1].
Args:
... |
import pytest
from redbot.pytest.alias import *
def test_is_valid_alias_name(alias):
assert alias.is_valid_alias_name("valid") is True
assert alias.is_valid_alias_name("not valid name") is False
@pytest.mark.asyncio
async def test_empty_guild_aliases(alias, empty_guild):
assert list(await alias._aliase... |
import ast
import pytest
from homeassistant.components import media_source
from homeassistant.components.media_source import const
from homeassistant.components.media_source.models import PlayMedia
from homeassistant.components.netatmo import DATA_CAMERAS, DATA_EVENTS, DOMAIN
from homeassistant.setup import async_se... |
import asyncio
from datetime import timedelta
import logging
import async_timeout
from iammeter import real_time_api
from iammeter.power_meter import IamMeterError
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT
from... |
from pyairvisual.errors import InvalidKeyError, NodeProError
from homeassistant import data_entry_flow
from homeassistant.components.airvisual import (
CONF_GEOGRAPHIES,
CONF_INTEGRATION_TYPE,
DOMAIN,
INTEGRATION_TYPE_GEOGRAPHY,
INTEGRATION_TYPE_NODE_PRO,
)
from homeassistant.config_entries import... |
from os import environ, cpu_count
import configparser
import os.path
import sys
# Read in the default config file if /etc/httpobs.conf doesn't already exist
__dirname = os.path.abspath(os.path.dirname(__file__))
_config_parser = configparser.ConfigParser()
_config_parser.read_file(open(os.path.join(__dirname, 'http... |
import re
import unittest
import forecastio
from requests.exceptions import ConnectionError
import requests_mock
from homeassistant.components import weather
from homeassistant.setup import setup_component
from homeassistant.util.unit_system import METRIC_SYSTEM
from tests.async_mock import patch
from tests.common ... |
import signal
def signal_to_exception(signum, frame):
"""
Called by the timeout alarm during the collector run time
"""
if signum == signal.SIGALRM:
raise SIGALRMException()
if signum == signal.SIGHUP:
raise SIGHUPException()
if signum == signal.SIGUSR1:
raise SIGUSR1E... |
import asyncio
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_SCAN_INTERVAL,
CONF_SSL,
CONF_USERNAME,
)
from homeassistant.exceptions import ConfigEntryNotR... |
import time
from homeassistant.components.switch import DOMAIN, SwitchEntity
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from . import ZWaveDeviceEntity, workaround
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up Z... |
from datetime import datetime, timedelta
import logging
import ns_api
from ns_api import RequestParametersError
import requests
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import ATTR_ATTRIBUTION, CONF_API_KEY, CONF_NAME
from homeassistant.exceptions ... |
import logging
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.const import ATTR_ATTRIBUTION, CONF_HOST, CONF_PORT
from . import CONF_CONTAINERS, CONF_NODES, CONF_VMS, PROXMOX_CLIENTS, ProxmoxItemType
ATTRIBUTION = "Data provided by Proxmox VE"
_LOGGER = logging.getLogger(__... |
from plumbum.path.base import Path
from plumbum.lib import six
from plumbum.machines.local import local, LocalPath
import os
def delete(*paths):
"""Deletes the given paths. The arguments can be either strings,
:class:`local paths <plumbum.path.local.LocalPath>`,
:class:`remote paths <plumbum.path.remote.... |
import numpy as np
from scipy import linalg
from scipy.linalg import LinAlgError
from scipy._lib._util import _asarray_validated
_d = np.empty(0, np.float64)
_z = np.empty(0, np.complex128)
dgemm = linalg.get_blas_funcs('gemm', (_d,))
zgemm = linalg.get_blas_funcs('gemm', (_z,))
dgemv = linalg.get_blas_funcs('gemv', ... |
import os
import shutil
import unittest
import subprocess
import shlex
import sqlite3
def run_cmd(app, cmd):
"""Run a command and return a tuple with (stdout, stderr, exit_code)"""
os.environ['FLASK_APP'] = app
process = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE,
... |
import hkavr
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
SUPPORT_SELECT_SOURCE,
SUPPORT_TURN_OFF,
SUPPORT_TURN_ON,
SUPPORT_VOLUME_MUTE,
SUPPORT_VOLUME_STEP,
)
from homeassist... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.