text stringlengths 213 32.3k |
|---|
import sys
import os.path
def error(message, *args):
if args:
message = message % args
sys.stderr.write('ERROR: %s\n' % message)
try:
import lxml.etree as et
except ImportError:
error(sys.exc_info()[1])
sys.exit(5)
try:
basestring
except NameError:
basestring = (str, bytes)
try:... |
from homematicip.base.enums import SmokeDetectorAlarmType, WindowState
from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN
from homeassistant.components.homematicip_cloud.binary_sensor import (
ATTR_ACCELER... |
import asyncio
import datetime
import logging
from aiohomekit.exceptions import (
AccessoryDisconnectedError,
AccessoryNotFoundError,
EncryptionError,
)
from aiohomekit.model import Accessories
from aiohomekit.model.characteristics import CharacteristicsTypes
from aiohomekit.model.services import Services... |
import asyncio
from datetime import timedelta
import os
from homeassistant.helpers import storage
from homeassistant.util import dt
from tests.async_mock import patch
from tests.common import async_fire_time_changed, async_test_home_assistant
async def test_removing_while_delay_in_progress(tmpdir):
"""Test rem... |
from __future__ import division
import numpy as np
import chainer
import chainer.functions as F
from chainer import initializers
import chainer.links as L
from chainercv.links import Conv2DBNActiv
from chainercv.links.model.resnet import ResBlock
from chainercv.links import PickableSequentialChain
from chainercv im... |
import os
import platform
import pytest
from pathlib import Path
from mne.utils import (set_config, get_config, get_config_path,
set_memmap_min_size, _get_stim_channel, sys_info,
ClosingStringIO)
def test_config(tmpdir):
"""Test mne-python config file support."""
... |
import unittest.mock
import pytest
from qutebrowser.misc import cmdhistory
from qutebrowser.utils import objreg
HISTORY = ['first', 'second', 'third', 'fourth', 'fifth']
@pytest.fixture
def hist():
return cmdhistory.History(history=HISTORY)
def test_no_history():
hist = cmdhistory.History()
assert ... |
from homeassistant.const import (
DEVICE_CLASS_PRESSURE,
DEVICE_CLASS_TEMPERATURE,
PERCENTAGE,
PRESSURE_BAR,
TEMP_CELSIUS,
TEMP_FAHRENHEIT,
TIME_HOURS,
)
from . import DOMAIN, AtagEntity
SENSORS = {
"Outside Temperature": "outside_temp",
"Average Outside Temperature": "tout_avg",
... |
import os.path as op
import numpy as np
from numpy.testing import (assert_array_almost_equal, assert_array_equal,
assert_equal, assert_allclose)
import pytest
from mne import (read_cov, read_forward_solution, convert_forward_solution,
pick_types_forward, read_evokeds, pick... |
import asyncio
import logging
import re
import aiohttp
from aiohttp.hdrs import REFERER, USER_AGENT
import async_timeout
from gtts_token import gtts_token
import voluptuous as vol
from homeassistant.components.tts import CONF_LANG, PLATFORM_SCHEMA, Provider
from homeassistant.const import HTTP_OK
from homeassistant.... |
import hangups
from common import run_example
async def query_presence(client, args):
request = hangups.hangouts_pb2.QueryPresenceRequest(
request_header=client.get_request_header(),
participant_id=[
hangups.hangouts_pb2.ParticipantId(gaia_id=args.user_id),
],
field_m... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from nets import resnet_utils
resnet_arg_scope = resnet_utils.resnet_arg_scope
slim = tf.contrib.slim
@slim.add_arg_scope
def bottleneck(inputs, depth, depth_bottleneck, stride, ra... |
import argparse
import json
import sys
from paasta_tools.kubernetes_tools import get_kubernetes_services_running_here_for_nerve
from paasta_tools.marathon_tools import get_marathon_services_running_here_for_nerve
from paasta_tools.marathon_tools import get_puppet_services_running_here_for_nerve
from paasta_tools.util... |
import unittest
import numpy as np
from chainer.testing import attr
from chainer import Variable
from chainercv.links import ResNet101
from chainercv.links import ResNet152
from chainercv.links import ResNet50
from chainercv.utils import testing
@testing.parameterize(*(
testing.product_dict(
[
... |
import os
import re
import subprocess
import Queue
from Handler import Handler
#
# Constants for RRD file creation.
#
# NOTE: We default to the collectd RRD directory
# simply as a compatibility tool. Users that have
# tools that look in that location and would like
# to switch to Diamond need to make zero changes.... |
import asyncio
from functools import wraps
import logging
import aiohttp
import async_timeout
import attr
from hass_nabucasa import Cloud, auth, thingtalk
from hass_nabucasa.const import STATE_DISCONNECTED
import voluptuous as vol
from homeassistant.components import websocket_api
from homeassistant.components.alexa... |
import io
import logging
import os
import sys
import time
from PIL import Image, ImageDraw, UnidentifiedImageError
import numpy as np
import tensorflow as tf # pylint: disable=import-error
import voluptuous as vol
from homeassistant.components.image_processing import (
CONF_CONFIDENCE,
CONF_ENTITY_ID,
C... |
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.kodi import DOMAIN
from homeassistant.components.media_player.const import DOMAIN as MP_DOMAIN
from homeassistant.setup import async_setup_component
from . import init_integration
from tests.common import (
Mock... |
import datetime
import json
import numpy as np
from qstrader import settings
import qstrader.statistics.performance as perf
class JSONStatistics(object):
"""
Standalone class to output basic backtesting statistics
into a JSON file format.
Parameters
----------
equity_curve : `pd.DataFrame`... |
import pandas as pd
from urllib.request import urlopen
import scattertext as st
def main():
shisei = _parse_geutenberg('http://www.gutenberg.org/files/31617/31617-0.txt')
horadanshaku = _parse_geutenberg('http://www.gutenberg.org/files/34084/34084-0.txt')
df = pd.DataFrame({'text': [shisei, horadanshaku],
... |
from __future__ import print_function
import argparse
import os
import sys
import io
import six
_stash = globals()["_stash"]
def main(args):
ap = argparse.ArgumentParser()
ap.add_argument('file', nargs='?', help='the file to be pasted')
ns = ap.parse_args(args)
status = 0
if not hasattr... |
import diamond.collector
try:
import psycopg2
import psycopg2.extensions
psycopg2 # workaround for pyflakes issue #13
except ImportError:
psycopg2 = None
class SlonyCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(SlonyCollector, self).get_... |
from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
from homeassistant.helpers.entity import Entity
from .const import DOMAIN
from .device import ONVIFDevice
from .models import Profile
class ONVIFBaseEntity(Entity):
"""Base class common to all ONVIF entities."""
def __init__(self, dev... |
from docutils import nodes
from docutils.parsers.rst import roles
from nikola.utils import split_explicit_title, LOGGER, slugify
from nikola.plugin_categories import RestExtension
class Plugin(RestExtension):
"""Plugin for doc role."""
name = 'rest_doc'
def set_site(self, site):
"""Set Nikola ... |
from collections import defaultdict
import socket
import diamond.collector
from diamond.metric import Metric
def parse_slab_stats(slab_stats):
"""Convert output from memcached's `stats slabs` into a Python dict.
Newlines are returned by memcached along with carriage returns
(i.e. '\r\n').
>>> pars... |
import json
import ntpath
from absl import flags
from perfkitbenchmarker import background_tasks
from perfkitbenchmarker import errors
from perfkitbenchmarker import sample
from perfkitbenchmarker import vm_util
FLAGS = flags.FLAGS
TEST_PORT = 5000
PSPING_OUTPUT_FILE = 'psping_out'
PSPING_DIR = 'PSTools'
PSPING_ZIP... |
import logging
from homeassistant.components.cover import (
ATTR_POSITION,
SUPPORT_CLOSE,
SUPPORT_OPEN,
SUPPORT_SET_POSITION,
CoverEntity,
)
from . import LUTRON_CONTROLLER, LUTRON_DEVICES, LutronDevice
_LOGGER = logging.getLogger(__name__)
def setup_platform(hass, config, add_entities, discov... |
import os.path
from django import template
from django.template.defaulttags import do_for, do_if
register = template.Library()
@register.simple_tag()
def replace(value, char, replace_char):
return value.replace(char, replace_char)
@register.filter
def dirname(value):
return os.path.dirname(value)
@regi... |
import pytest
from qstrader.broker.fee_model.percent_fee_model import PercentFeeModel
class AssetMock(object):
def __init__(self):
pass
class BrokerMock(object):
def __init__(self):
pass
@pytest.mark.parametrize(
"commission_pct,tax_pct,quantity,consideration,"
"expected_commissi... |
from concurrent import futures
from datetime import timedelta
import logging
from pytfiac import Tfiac
import voluptuous as vol
from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateEntity
from homeassistant.components.climate.const import (
FAN_AUTO,
FAN_HIGH,
FAN_LOW,
FAN_MEDIUM,
... |
import contextlib
import fcntl
import itertools
import os
import signal
import sys
import time
import mock
import pytest
from paasta_tools import mac_address
skip_if_osx = pytest.mark.skipif(
sys.platform == "darwin", reason="Flock is not present on OS X"
)
def test_simple(tmpdir):
mac, lock_file = mac_a... |
import asyncio
from datetime import timedelta
from typing import Optional
from twentemilieu import TwenteMilieu
import voluptuous as vol
from homeassistant.components.twentemilieu.const import (
CONF_HOUSE_LETTER,
CONF_HOUSE_NUMBER,
CONF_POST_CODE,
DATA_UPDATE,
DOMAIN,
)
from homeassistant.config... |
import functools
from http import server
import logging
import multiprocessing
import os
import subprocess
import sys
import threading
import time
# Amount of time in seconds to attempt calling a client VM if VM calling in.
MAX_TIME_SECONDS = 30
# Amount of time in seconds to attempt calling a client VM if VM not ca... |
from homeassistant.components.device_tracker import DeviceScanner
from homeassistant.components.opnsense import CONF_TRACKER_INTERFACE, OPNSENSE_DATA
async def async_get_scanner(hass, config, discovery_info=None):
"""Configure the OPNSense device_tracker."""
interface_client = hass.data[OPNSENSE_DATA]["inter... |
import sys
from .compat3 import basestring_
__all__ = ['looper']
class looper(object):
"""
Helper for looping (particularly in templates)
Use this like::
for loop, item in looper(seq):
if loop.first:
...
"""
def __init__(self, seq):
self.seq = seq
... |
INLINESTYLES = False
STYLE = "fruity"
from pygments.formatters import HtmlFormatter
# The default formatter
DEFAULT = HtmlFormatter(noclasses=INLINESTYLES, style=STYLE)
# Add name -> formatter pairs for every variant you want to use
VARIANTS = {
# 'linenos': HtmlFormatter(noclasses=INLINESTYLES, linenos=True),
... |
from homeassistant.components.weather import WeatherEntity
from homeassistant.const import LENGTH_KILOMETERS, TEMP_CELSIUS
from homeassistant.core import callback
from homeassistant.helpers.typing import ConfigType, HomeAssistantType
from .const import (
ATTRIBUTION,
CONDITION_CLASSES,
DEFAULT_NAME,
D... |
import logging
from pydanfossair.commands import ReadCommand
from homeassistant.const import (
DEVICE_CLASS_BATTERY,
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_TEMPERATURE,
PERCENTAGE,
TEMP_CELSIUS,
)
from homeassistant.helpers.entity import Entity
from . import DOMAIN as DANFOSS_AIR_DOMAIN
_LOGGER = ... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import logging
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import managed_memory_store
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_packages im... |
from django import template
from django.utils.safestring import mark_safe
from django.utils.translation import gettext as _
from weblate.utils.checks import check_doc_link
register = template.Library()
@register.simple_tag
def check_link(check):
fallback = None
if check.hint and check.hint.startswith("http... |
import re
from coverage.templite import Templite, TempliteSyntaxError, TempliteValueError
from tests.coveragetest import CoverageTest
# pylint: disable=possibly-unused-variable
class AnyOldObject(object):
"""Simple testing object.
Use keyword arguments in the constructor to set attributes on the object.
... |
import time
import mock
from behave import then
from behave import when
from paasta_tools.cli.cmds import logs
@when("we tail paasta logs and let threads run")
def tail_paasta_logs_let_threads_be_threads(context):
"""This test lets tail_paasta_logs() fire off processes to do work. We
verify that the work w... |
import logging
from libpurecool.dyson_pure_cool import DysonPureCool
from libpurecool.dyson_pure_state_v2 import DysonEnvironmentalSensorV2State
from homeassistant.components.air_quality import DOMAIN, AirQualityEntity
from . import DYSON_DEVICES
ATTRIBUTION = "Dyson purifier air quality sensor"
_LOGGER = logging... |
import unittest
import numpy as np
from hep_ml.preprocessing import BinTransformer
class TestHepML(unittest.TestCase):
def test_preprocessing(self):
X = np.array([[1.1, 1.2, 1.3],[5.1, 6.4, 10.5]])
transformer = BinTransformer().fit(X)
new_X = transformer.transform(X)
self.asser... |
import argparse
from PyQt5.QtCore import QUrl
from qutebrowser.commands import cmdexc
from qutebrowser.utils import utils, objreg, log
SUPPRESS = argparse.SUPPRESS
class ArgumentParserError(Exception):
"""Exception raised when the ArgumentParser signals an error."""
class ArgumentParserExit(Exception):
... |
import contextlib
import asynctest
import mock
import pytest
from paasta_tools import drain_lib
def test_register_drain_method():
with mock.patch.dict(drain_lib._drain_methods):
@drain_lib.register_drain_method("FAKEDRAINMETHOD")
class FakeDrainMethod(drain_lib.DrainMethod):
pass
... |
from os import path
from homeassistant import config as hass_config, setup
from homeassistant.components.ping import DOMAIN
from homeassistant.const import SERVICE_RELOAD
from tests.async_mock import patch
async def test_reload(hass):
"""Verify we can reload trend sensors."""
await setup.async_setup_compo... |
from .visitor import NodeVisitor
VAR_LOAD_PARAMETER = "param"
VAR_LOAD_RESOLVE = "resolve"
VAR_LOAD_ALIAS = "alias"
VAR_LOAD_UNDEFINED = "undefined"
def find_symbols(nodes, parent_symbols=None):
sym = Symbols(parent=parent_symbols)
visitor = FrameSymbolVisitor(sym)
for node in nodes:
visitor.vis... |
import logging
from cheroot.test import webtest
import pytest
import requests # FIXME: Temporary using it directly, better switch
import cherrypy
from cherrypy.test.logtest import LogCase
# Some unicode strings.
tartaros = u'\u03a4\u1f71\u03c1\u03c4\u03b1\u03c1\u03bf\u03c2'
erebos = u'\u0388\u03c1\u03b5\u03b2\u03... |
from contextlib import asynccontextmanager
from datetime import timedelta
from typing import Any, Dict, List, Optional
import pytest
from pytest import raises
from pyvizio.api.apps import AppConfig
from pyvizio.const import (
APPS,
DEVICE_CLASS_SPEAKER as VIZIO_DEVICE_CLASS_SPEAKER,
DEVICE_CLASS_TV as VIZ... |
from homeassistant.components.vacuum import (
ATTR_FAN_SPEED,
SERVICE_PAUSE,
SERVICE_RETURN_TO_BASE,
SERVICE_SET_FAN_SPEED,
SERVICE_START,
SERVICE_STOP,
STATE_CLEANING,
STATE_DOCKED,
STATE_RETURNING,
)
from homeassistant.const import (
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
... |
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from shop.modifiers.base import BaseCartModifier
class ShippingModifier(BaseCartModifier):
"""
Base class for all shipping modifiers. The purpose of a shipping modifier is to calculate the shipping costs and/or
preve... |
import configparser
import re
from radicale import pathutils, rights
from radicale.log import logger
class Rights(rights.BaseRights):
def __init__(self, configuration):
super().__init__(configuration)
self._filename = configuration.get("rights", "file")
def authorization(self, user, path):
... |
from itertools import *
import benchbase
from benchbase import (with_text, children, nochange)
############################################################
# Benchmarks
############################################################
class BenchMark(benchbase.TreeBenchMark):
repeat100 = range(100)
repeat1000 =... |
from six import text_type as str
from subliminal.utils import hash_opensubtitles, hash_thesubdb, sanitize
def test_hash_opensubtitles(mkv):
assert hash_opensubtitles(mkv['test1']) == '40b44a7096b71ec3'
def test_hash_opensubtitles_too_small(tmpdir):
path = tmpdir.ensure('test_too_small.mkv')
assert has... |
from __future__ import print_function
import os
import tempfile
import console
import editor
import time
import argparse
_stash = globals()["_stash"]
try:
raw_input
except NameError:
raw_input = input
def open_temp(file='', new_tab=True):
try:
file_to_edit = file
temp = tempfile.NamedTe... |
from collections import defaultdict
import logging
from requests.exceptions import RequestException
from tahoma_api import Action, TahomaApi
import voluptuous as vol
from homeassistant.const import CONF_EXCLUDE, CONF_PASSWORD, CONF_USERNAME
from homeassistant.helpers import config_validation as cv, discovery
from ho... |
import os
import subprocess
import pytest
from homeassistant.util import process
async def test_kill_process():
"""Test killing a process."""
sleeper = subprocess.Popen(
"sleep 1000",
shell=True, # nosec # shell by design
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL... |
import cherrypy
from cherrypy.test import helper
script_names = ['', '/foo', '/users/fred/blog', '/corp/blog']
def setup_server():
class SubSubRoot:
@cherrypy.expose
def index(self):
return 'SubSubRoot index'
@cherrypy.expose
def default(self, *args):
re... |
from io import BytesIO
import http.client
"""
The python3 http.client api moved some stuff around, so this is an abstraction
layer that tries to cope with this move.
"""
def get_header(message, name):
return message.getallmatchingheaders(name)
def get_header_items(message):
for (key, values) in get_heade... |
from homeassistant.components.alarm_control_panel import DOMAIN
from homeassistant.const import (
ATTR_CODE,
ATTR_ENTITY_ID,
ENTITY_MATCH_ALL,
SERVICE_ALARM_ARM_AWAY,
SERVICE_ALARM_ARM_CUSTOM_BYPASS,
SERVICE_ALARM_ARM_HOME,
SERVICE_ALARM_ARM_NIGHT,
SERVICE_ALARM_DISARM,
SERVICE_ALAR... |
from datetime import timedelta
import logging
from pybotvac.exceptions import NeatoRobotException
from homeassistant.components.camera import Camera
from .const import (
NEATO_DOMAIN,
NEATO_LOGIN,
NEATO_MAP_DATA,
NEATO_ROBOTS,
SCAN_INTERVAL_MINUTES,
)
_LOGGER = logging.getLogger(__name__)
SCAN... |
from gi.repository import Gio
def replace_menu_section(menu: Gio.Menu, section: Gio.MenuItem):
"""Replaces an existing section in GMenu `menu` with `section`
The sections are compared by their `id` attributes, with the
matching section in `menu` being replaced by the passed `section`.
If there is n... |
import re
from enum import Enum
from io import StringIO
import natsort
from nikola.plugin_categories import MetadataExtractor
from nikola.utils import unslugify
__all__ = ('MetaCondition', 'MetaPriority', 'MetaSource', 'check_conditions')
_default_extractors = []
DEFAULT_EXTRACTOR_NAME = 'nikola'
DEFAULT_EXTRACTOR ... |
from typing import Dict, List
import voluptuous as vol
from homeassistant.const import (
ATTR_ENTITY_ID,
CONF_CONDITION,
CONF_DEVICE_ID,
CONF_DOMAIN,
CONF_ENTITY_ID,
CONF_TYPE,
STATE_IDLE,
STATE_OFF,
STATE_ON,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.core import H... |
import asyncio
from datetime import timedelta
import logging
from accuweather import AccuWeather, ApiError, InvalidApiKeyError, RequestsExceededError
from aiohttp.client_exceptions import ClientConnectorError
from async_timeout import timeout
from homeassistant.const import CONF_API_KEY
from homeassistant.core impor... |
from typing import Optional
from google_nest_sdm.device import Device
from google_nest_sdm.device_traits import HumidityTrait, TemperatureTrait
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_TEMPERATURE,
PERCENTAGE,
TEMP_CELS... |
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_MOISTURE,
DEVICE_CLASS_MOTION,
BinarySensorEntity,
)
from . import DOMAIN
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the Demo binary sensor platform."""
async_add_entities(
... |
import logging
import unittest
import numpy as np
import scipy.linalg
from gensim import matutils
from gensim.corpora.mmcorpus import MmCorpus
from gensim.models import lsimodel
from gensim.test import basetmtests
from gensim.test.utils import datapath, get_tmpfile
class TestLsiModel(unittest.TestCase, basetmtests... |
import time
import pytest
import jax
import jax.config
jax.config.update("jax_enable_x64", True)
import jax.numpy as np
import jax.random
import tensornetwork as tn
import simple_mera
def test_descend(random_tensors):
h, s, iso, dis = random_tensors
s = simple_mera.descend(h, s, iso, dis)
assert len(s.shape) =... |
import voluptuous as vol
from homeassistant.components.alarm_control_panel import (
FORMAT_NUMBER,
AlarmControlPanelEntity,
)
from homeassistant.components.alarm_control_panel.const import (
SUPPORT_ALARM_ARM_AWAY,
SUPPORT_ALARM_ARM_HOME,
SUPPORT_ALARM_ARM_NIGHT,
)
from homeassistant.config_entrie... |
import glob
import importlib
import os
import os.path as op
from optparse import OptionParser
import sys
import mne
def _add_verbose_flag(parser):
parser.add_option("--verbose", dest='verbose',
help="Enable verbose mode (printing of log messages).",
default=None, acti... |
import numpy
from affinegap import normalizedAffineGapDistance as comparator
def getCentroid(attribute_variants, comparator):
"""
Takes in a list of attribute values for a field,
evaluates the centroid using the comparator,
& returns the centroid (i.e. the 'best' value for the field)
"""
n =... |
import json
import logging
import os
from rtmapi import Rtm, RtmRequestFailedException
import voluptuous as vol
from homeassistant.const import CONF_API_KEY, CONF_ID, CONF_NAME, CONF_TOKEN, STATE_OK
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
from homeassistan... |
import json
import arrow
from flask import current_app
from lemur.plugins.bases import ExpirationNotificationPlugin
from lemur.plugins import lemur_slack as slack
import requests
def create_certificate_url(name):
return "https://{hostname}/#/certificates/{name}".format(
hostname=current_app.config.get("... |
import pytest
from lemur.tests.vectors import INTERNAL_PRIVATE_KEY_A_STR, INTERNAL_CERTIFICATE_A_STR
def test_export_certificate_to_csr(app):
from lemur.plugins.base import plugins
p = plugins.get("openssl-csr")
options = []
with pytest.raises(Exception):
p.export(INTERNAL_CERTIFICATE_A_STR,... |
import pytest
from homeassistant.components.alarm_control_panel import DOMAIN
import homeassistant.components.automation as automation
from homeassistant.const import (
STATE_ALARM_ARMED_AWAY,
STATE_ALARM_ARMED_HOME,
STATE_ALARM_ARMED_NIGHT,
STATE_ALARM_DISARMED,
STATE_ALARM_PENDING,
STATE_ALA... |
import codecs
import errno
import io
import os
import re
import shutil
import stat
import tempfile
from collections import defaultdict
from meld.conf import _, ngettext
from . import _vc
NULL_SHA = "0000000000000000000000000000000000000000"
class Vc(_vc.Vc):
CMD = "git"
NAME = "Git"
VC_DIR = ".git"
... |
import numpy as np
from hypertools.tools.procrustes import procrustes
from hypertools.tools.load import load
def test_procrustes_func():
target = load('spiral').get_data()[0]
rot = np.array([[-0.89433495, -0.44719485, -0.01348182],
[-0.43426149, 0.87492975, -0.21427761],
[-0.10761949,... |
import unittest
from chainer import testing
from chainer.testing import attr
from chainercv.datasets import camvid_label_names
from chainercv.datasets import CamVidDataset
from chainercv.utils import assert_is_semantic_segmentation_dataset
@testing.parameterize(
{'split': 'train'},
{'split': 'val'},
{'... |
import logging
import liffylights
import voluptuous as vol
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
ATTR_HS_COLOR,
ATTR_TRANSITION,
PLATFORM_SCHEMA,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_COLOR_TEMP,
SUPPORT_TRANSITION,
LightEntity,
)
... |
import asyncio
from copy import deepcopy
from homeassistant.components.deconz import (
DeconzGateway,
async_setup_entry,
async_unload_entry,
)
from homeassistant.components.deconz.const import DOMAIN as DECONZ_DOMAIN
from homeassistant.components.deconz.gateway import get_gateway_from_config_entry
from .... |
import collections
import re
import numpy as np
import pandas as pd
from scattertext.CSRMatrixTools import delete_columns, CSRMatrixFactory
from scattertext.FeatureOuput import FeatureLister
from scattertext.Common import SPACY_ENTITY_TAGS, MY_ENGLISH_STOP_WORDS, DEFAULT_BACKGROUND_SCALER_ALGO, \
DEFAULT_BACKGRO... |
import json
from django.core.serializers.json import DjangoJSONEncoder, Serializer as DjangoSerializer
from django.core.serializers.json import Deserializer
from shop.money.money_maker import AbstractMoney
__all__ = ['JSONEncoder', 'Serializer', 'Deserializer']
class JSONEncoder(DjangoJSONEncoder):
"""
Mon... |
from collections import OrderedDict
from pyvesync import VeSync
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import callback
from .const import DOMAIN
@callback
def configured_instances(hass):
"""Return a... |
from collections import OrderedDict
from homeassistant.helpers.entity_values import EntityValues as EV
ent = "test.test"
def test_override_single_value():
"""Test values with exact match."""
store = EV({ent: {"key": "value"}})
assert store.get(ent) == {"key": "value"}
assert len(store._cache) == 1
... |
from __future__ import absolute_import, unicode_literals
import copy
import logging
import os
from . import exc
from ._compat import string_types
logger = logging.getLogger(__name__)
def validate_schema(sconf):
"""
Return True if config schema is correct.
Parameters
----------
sconf : dict
... |
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.device_automation import (
_async_get_device_automations as async_get_device_automations,
)
from homeassistant.components.remote import DOMAIN
from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON
fro... |
import urwid
def menu_button(caption, callback):
button = urwid.Button(caption)
urwid.connect_signal(button, 'click', callback)
return urwid.AttrMap(button, None, focus_map='reversed')
def sub_menu(caption, choices):
contents = menu(caption, choices)
def open_menu(button):
return top.open... |
from ipaddress import ip_address
import logging
import os
from aiohttp import web
from aiohttp.web_exceptions import HTTPNotFound, HTTPUnauthorized
import voluptuous as vol
from homeassistant.auth.models import User
from homeassistant.auth.providers import homeassistant as auth_ha
from homeassistant.components.http ... |
import tensorflow as tf
from tensorflow.keras.layers import Layer # type: ignore
from tensorflow.keras import activations
from tensorflow.keras import initializers
from typing import List, Optional, Text, Tuple
import tensornetwork as tn
import numpy as np
# pytype: disable=module-attr
@tf.keras.utils.register_kera... |
from enocean.protocol.packet import Packet
from enocean.utils import combine_hex
from homeassistant.helpers.entity import Entity
from .const import SIGNAL_RECEIVE_MESSAGE, SIGNAL_SEND_MESSAGE
class EnOceanEntity(Entity):
"""Parent class for all entities associated with the EnOcean component."""
def __init... |
import argparse
import json
from weblate.auth.models import User
from weblate.utils.management.base import BaseCommand
class Command(BaseCommand):
help = "imports users from JSON dump of database"
def add_arguments(self, parser):
parser.add_argument(
"--check",
action="store... |
from homeassistant import config_entries, setup
from homeassistant.components.elkm1.const import DOMAIN
from tests.async_mock import MagicMock, patch
def mock_elk(invalid_auth=None, sync_complete=None):
"""Mock m1lib Elk."""
def handler_callbacks(type_, callback):
nonlocal invalid_auth, sync_comple... |
import posixpath
from perfkitbenchmarker import linux_packages
MYSQL_RPM = 'mysql56-community-release-el6-5.noarch.rpm'
MYSQL_PSWD = 'perfkitbenchmarker'
MYSQL_URL = 'https://dev.mysql.com/get/' + MYSQL_RPM
PACKAGE_NAME = 'mysql'
PREPROVISIONED_DATA = {
MYSQL_RPM:
'81b2256f778bb3972054257edda2c2a82fcec455... |
from homeassistant.components import tradfri
from homeassistant.helpers.device_registry import (
async_entries_for_config_entry,
async_get_registry as async_get_device_registry,
)
from homeassistant.setup import async_setup_component
from tests.async_mock import patch
from tests.common import MockConfigEntry
... |
from datetime import datetime as dt
from pyflick import FlickAPI
from pyflick.authentication import AbstractFlickAuth
from pyflick.const import DEFAULT_CLIENT_ID, DEFAULT_CLIENT_SECRET
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
CONF_ACCESS_TOKEN,
CONF_CLIENT_ID,
... |
import asyncio
from asyncio import CancelledError
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from .const import DATA_TASK, DOMAIN, PLATFORMS
async def async_setup(hass, config: dict):
"""Set up the DSMR platform."""
return True
async def async_setup_... |
from functools import partial
from ...utils import verbose
from ..utils import (has_dataset, _data_path, _get_version, _version_doc,
_data_path_doc_accept)
has_brainstorm_data = partial(has_dataset, name='brainstorm.bst_resting')
_description = u"""
URL: http://neuroimage.usc.edu/brainstorm/Dat... |
from __future__ import print_function
import sys
import argparse
import requests
from six.moves.urllib.parse import urlparse
try:
import clipboard
except ImportError:
clipboard = None
def main(args):
ap = argparse.ArgumentParser()
ap.add_argument('url', nargs='?', help='the url to read (default to ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.