text stringlengths 213 32.3k |
|---|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import os
import re
import struct
import sys
import textwrap
try:
import fcntl
except ImportError:
fcntl = None
try:
# Importing termios will fail on non-unix platforms.
import termi... |
from homeassistant.components.ozw.light import byte_to_zwave_brightness
from .common import setup_ozw
async def test_light(hass, light_data, light_msg, light_rgb_msg, sent_messages):
"""Test setting up config entry."""
receive_message = await setup_ozw(hass, fixture=light_data)
# Test loaded
state ... |
from __future__ import division
import argparse
import multiprocessing
import numpy as np
import chainer
from chainer import iterators
from chainer.links import Classifier
from chainer.optimizer import WeightDecay
from chainer.optimizers import CorrectedMomentumSGD
from chainer import training
from chainer.training i... |
from weblate.accounts.notifications import FREQ_INSTANT, SCOPE_ADMIN, SCOPE_WATCHED
DEFAULT_NOTIFICATIONS = [
(SCOPE_WATCHED, FREQ_INSTANT, "LastAuthorCommentNotificaton"),
(SCOPE_WATCHED, FREQ_INSTANT, "MentionCommentNotificaton"),
(SCOPE_WATCHED, FREQ_INSTANT, "NewAnnouncementNotificaton"),
(SCOPE_A... |
from aiohttp.web_exceptions import (
HTTPBadRequest,
HTTPInternalServerError,
HTTPUnauthorized,
)
import pytest
import voluptuous as vol
from homeassistant.components.http.view import (
HomeAssistantView,
request_handler_factory,
)
from homeassistant.exceptions import ServiceNotFound, Unauthorized... |
import logging
from requests import RequestException
from requests.exceptions import HTTPError
from stringcase import camelcase, snakecase
import thermoworks_smoke
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_BATTERY_LEVEL,
CONF_E... |
import logging
from typing import List, Optional, cast
import voluptuous as vol
from homeassistant.auth import EVENT_USER_REMOVED
from homeassistant.components import websocket_api
from homeassistant.components.device_tracker import (
ATTR_SOURCE_TYPE,
DOMAIN as DEVICE_TRACKER_DOMAIN,
SOURCE_TYPE_GPS,
)
... |
from typing import Collection
from typing import List
from service_configuration_lib import read_service_configuration
from paasta_tools.cli.cmds.status import get_actual_deployments
from paasta_tools.cli.utils import figure_out_service_name
from paasta_tools.cli.utils import lazy_choices_completer
from paasta_tools... |
import pathlib
import tempfile
from aiohttp import ClientSession, ClientWebSocketResponse
from homeassistant.components.websocket_api import const as ws_const
from homeassistant.setup import async_setup_component
from homeassistant.util import dt as util_dt
from tests.async_mock import patch
async def test_upload... |
import json
import pytest
from lemur.authorities.views import * # noqa
from lemur.tests.factories import AuthorityFactory, RoleFactory
from lemur.tests.vectors import (
VALID_ADMIN_API_TOKEN,
VALID_ADMIN_HEADER_TOKEN,
VALID_USER_HEADER_TOKEN,
)
def test_authority_input_schema(client, role, issuer_plug... |
from datetime import timedelta
import os
import pytest
import voluptuous as vol
from homeassistant.components.device_tracker import (
CONF_CONSIDER_HOME,
CONF_NEW_DEVICE_DEFAULTS,
CONF_TRACK_NEW,
)
from homeassistant.components.device_tracker.legacy import YAML_DEVICES
from homeassistant.components.unifi... |
import pickle
import requests
from src.s3_client_deeposm import post_findings_to_s3
from src.single_layer_network import train_on_cached_data
from src.training_data import CACHE_PATH, METADATA_PATH, download_and_serialize
def main():
"""Analyze each state and publish results to deeposm.org."""
naip_year = ... |
from flask import Flask
from flasgger import Swagger
app = Flask(__name__)
swag = Swagger(app, config={
'headers': [],
'specs': [
{
'endpoint': 'apispec',
'route': '/apispec.json'
}
],
'openapi': '3.0.1'
})
def test_swag(client, specs_data):
"""
This t... |
import os
import sys
import site
from .environment import env
@env.catch_exceptions
def enable_virtualenv():
"""Enable virtualenv for vim.
:return bool:
"""
path = env.var('g:pymode_virtualenv_path')
# Normalize path to be an absolute path
# If an absolute path is provided, that path will ... |
import itertools
import tempfile
import os
import random
import collections
import warnings
import functools
from typing import (Iterator,
Tuple,
Mapping,
Sequence,
Union,
Generator,
Optional,
... |
from __future__ import division
import itertools
import numpy as np
import chainer
from chainer.backends import cuda
import chainer.functions as F
from chainer.links import Convolution2D
from chainercv.links import Conv2DBNActiv
from chainercv import utils
from chainercv.links.model.yolo.yolo_base import YOLOBase
... |
import re
import sys
import inspect
import os.path
import collections
import enum
from typing import Callable, MutableMapping, Optional, List, Union
import qutebrowser
from qutebrowser.utils import log, utils
def is_git_repo() -> bool:
"""Check if we're running from a git repository."""
gitfolder = os.path.... |
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 nfs import NfsCollector
#########... |
import collections
import json
import unittest
from perfkitbenchmarker import sample
from perfkitbenchmarker import test_util
from perfkitbenchmarker.windows_packages import psping
psping_results = """
PsPing v2.10 - PsPing - ping, latency, bandwidth measurement utility
Copyright (C) 2012-2016 Mark Russinovich
Sysi... |
from functools import partial
from homeassistant.const import CONF_WEBHOOK_ID
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from .const import (
ATTR_SENSOR_STATE,
ATTR_SENSOR_TYPE_SENSOR as ENTITY_TYPE,
ATTR_SENSOR_UNIQUE_ID,
ATTR_SENSO... |
from cerberus import errors
from cerberus.tests import assert_fail
def test_items(validator):
field = 'a_list_of_values'
value = ['a string', 'not an integer']
assert_fail(
document={field: value},
validator=validator,
error=(
field,
(field, 'items'),
... |
import logging
from ciscomobilityexpress.ciscome import CiscoMobilityExpress
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_SSL,
CONF_USERNAME,
CO... |
import io
import csv
import datetime
import os
from urllib.parse import urlparse
from lxml import etree, html
from mako.template import Template
from pkg_resources import resource_filename
from nikola import utils
links = {}
class ImportMixin(object):
"""Mixin with common used methods."""
name = "import_... |
import os
from urllib.parse import urlsplit
from django.db import models
from django.http.response import Http404, HttpResponseRedirect
from django.http.request import QueryDict
from django.shortcuts import get_object_or_404
from django.utils.cache import add_never_cache_headers
from django.utils.encoding import forc... |
import pandas as pd
from arctic.date import DateRange, to_pandas_closed_closed
from ._chunker import Chunker, START, END
class DateChunker(Chunker):
TYPE = 'date'
def to_chunks(self, df, chunk_size='D', func=None, **kwargs):
"""
chunks the dataframe/series by dates
Parameters
... |
from unittest.mock import Mock
import pandas as pd
import pytest
import pytz
from qstrader.portcon.order_sizer.dollar_weighted import (
DollarWeightedCashBufferedOrderSizer
)
@pytest.mark.parametrize(
"cash_buffer_perc,expected",
[
(-1.0, None),
(0.0, 0.0),
(0.5, 0.5),
... |
import requests
from django.core.cache import cache
from weblate import USER_AGENT
from weblate.logger import LOGGER
from weblate.utils.errors import report_error
def request(method, url, headers=None, **kwargs):
agent = {"User-Agent": USER_AGENT}
if headers:
headers.update(agent)
else:
... |
import re
import sys
import glob
import os.path
import platform
import subprocess
import importlib
import collections
import enum
import datetime
import getpass
import functools
from typing import Mapping, Optional, Sequence, Tuple, cast
import attr
import pkg_resources
from PyQt5.QtCore import PYQT_VERSION_STR, QLib... |
from collections import namedtuple
import logging
import requests
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_TYPE,
CONF_USERNAME,
HTTP_OK,
)
i... |
import numpy as np
from numpy.polynomial.legendre import legval
from scipy import linalg
from ..utils import logger, warn, verbose
from ..io.meas_info import _simplify_info
from ..io.pick import pick_types, pick_channels, pick_info
from ..surface import _normalize_vectors
from ..forward import _map_meg_or_eeg_channel... |
import contextlib
import logging
import urllib.parse
import pytest
asyncio = pytest.importorskip("asyncio")
aiohttp = pytest.importorskip("aiohttp")
import vcr # noqa: E402
from .aiohttp_utils import aiohttp_app, aiohttp_request # noqa: E402
def run_in_loop(fn):
with contextlib.closing(asyncio.new_event_loo... |
from PyQt5.QtWebEngineWidgets import QWebEngineCertificateError
from qutebrowser.utils import usertypes, utils, debug
class CertificateErrorWrapper(usertypes.AbstractCertificateErrorWrapper):
"""A wrapper over a QWebEngineCertificateError."""
def __init__(self, error):
super().__init__(error)
... |
import argparse
import chainer
from chainer import iterators
from chainercv.datasets import ade20k_semantic_segmentation_label_names
from chainercv.datasets import ADE20KSemanticSegmentationDataset
from chainercv.datasets import camvid_label_names
from chainercv.datasets import CamVidDataset
from chainercv.datasets ... |
from django.db import migrations
def fix_rename_changes(apps, schema_editor):
Change = apps.get_model("trans", "Change")
db_alias = schema_editor.connection.alias
for change in (
Change.objects.using(db_alias)
.filter(action__in=[41, 42, 43])
.select_related("project", "component"... |
import socket
import unittest
from homeassistant.const import TEMP_CELSIUS
from homeassistant.setup import setup_component
from tests.async_mock import patch
from tests.common import get_test_home_assistant
VALID_CONFIG_MINIMAL = {"sensor": {"platform": "hddtemp"}}
VALID_CONFIG_NAME = {"sensor": {"platform": "hddt... |
from typing import Any, Optional, Union, Text, Sequence, Tuple, List
import numpy as np
Tensor = Any
def tensordot(tf, a, b, axes, name: Optional[Text] = None) -> Tensor:
r"""Tensor contraction of a and b along specified axes.
Tensordot (also known as tensor contraction) sums the product of elements
from `a` ... |
import io
import os
import re
import sys
import time
import unittest
try:
from cStringIO import StringIO
except ImportError:
from io import StringIO
from spinners.spinners import Spinners
from halo import Halo
from halo._utils import get_terminal_columns, is_supported
from tests._utils import strip_ansi, fi... |
import os
import sys
import shutil
try:
import setuptools # noqa, analysis:ignore
except ImportError:
pass # setuptools allows for "develop", but it's not essential
from distutils.core import setup
## Function we need
def get_version_and_doc(filename):
NS = dict(__version__='', __doc__='')
docSt... |
import copy
import httplib2
import pytest
from homeassistant.components.google import (
CONF_CAL_ID,
CONF_CLIENT_ID,
CONF_CLIENT_SECRET,
CONF_DEVICE_ID,
CONF_ENTITIES,
CONF_NAME,
CONF_TRACK,
DEVICE_SCHEMA,
SERVICE_SCAN_CALENDARS,
do_setup,
)
from homeassistant.const import STA... |
import logging
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
HVAC_MODE_COOL,
HVAC_MODE_DRY,
HVAC_MODE_FAN_ONLY,
HVAC_MODE_HEAT,
HVAC_MODE_HEAT_COOL,
HVAC_MODE_OFF,
SUPPORT_FAN_MODE,
SUPPORT_TARGET_TEMPERATURE,
)
from hom... |
from datetime import timedelta
import logging
import requests
import voluptuous as vol
import xmltodict
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import ATTR_ATTRIBUTION, CONF_API_KEY, CONF_NAME
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers... |
from matchzoo.data_pack import DataPack
from .units import Vocabulary
from .build_unit_from_data_pack import build_unit_from_data_pack
from .units import BertVocabulary
def build_vocab_unit(
data_pack: DataPack,
mode: str = 'both',
verbose: int = 1
) -> Vocabulary:
"""
Build a :class:... |
import numpy as np
import matchzoo as mz
from matchzoo.data_generator.callbacks import Callback
class Histogram(Callback):
"""
Generate data with matching histogram.
:param embedding_matrix: The embedding matrix used to generator match
histogram.
:param bin_size: The nu... |
import base64
import getpass
import logging
import bson
import pytest as pytest
from .. import arctic as m
from ..chunkstore.chunkstore import CHUNK_STORE_TYPE
from ..store.bitemporal_store import BitemporalStore
from ..tickstore.tickstore import TICK_STORE_TYPE
logger = logging.getLogger(__name__)
@pytest.fixtur... |
import logging
from typing import Any, Callable, Dict, List, Optional
import attr
from huawei_lte_api.enums.cradle import ConnectionStatusEnum
from homeassistant.components.binary_sensor import (
DOMAIN as BINARY_SENSOR_DOMAIN,
BinarySensorEntity,
)
from homeassistant.config_entries import ConfigEntry
from h... |
from collections import deque
import io
import logging
import time
import av
from .const import (
MAX_MISSING_DTS,
MAX_TIMESTAMP_GAP,
MIN_SEGMENT_DURATION,
PACKETS_TO_WAIT_FOR_AUDIO,
STREAM_TIMEOUT,
)
from .core import Segment, StreamBuffer
_LOGGER = logging.getLogger(__name__)
def create_stre... |
import json
from flask import Response
def build_json(result):
return Response(response=json.dumps(result),
status=200,
mimetype="application/json")
def sent_json(result):
return Response(response=result,
status=200,
mimetype=... |
from homeassistant.const import (
ATTR_ATTRIBUTION,
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_TEMPERATURE,
LENGTH_KILOMETERS,
PERCENTAGE,
SPEED_MILES_PER_HOUR,
TEMP_CELSIUS,
UV_INDEX,
)
from homeassistant.core import callback
from homeassistant.helpers.entity import Entity
from homeassistant.... |
import copy
import logging
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import dpb_service
from perfkitbenchmarker import errors
from perfkitbenchmarker import sample
from perfkitbenchmarker.dpb_service import BaseDpbService
BENCHMARK_NAME = 'dpb_cluster_boot_benchmark'
BENCH... |
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.resblock import ResBlock
from chainercv.links import PickableSequentialChain
from cha... |
import json
import logging
import string
import threading
from absl import flags
from perfkitbenchmarker import disk
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers.alicloud import util
FLAGS = flags.FLAGS
DISK_TYPE = {
disk.STANDARD: 'cloud',
disk.REMOTE_SSD: 'cloud_ssd',
disk.P... |
import sys
import urwid
class DialogExit(Exception):
pass
class DialogDisplay:
palette = [
('body','black','light gray', 'standout'),
('border','black','dark blue'),
('shadow','white','black'),
('selectable','black', 'dark cyan'),
('focus','white','dark blue','bold'... |
import pytest
import voluptuous as vol
import homeassistant.components.media_player as mp
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_ENTITY_PICTURE,
ATTR_SUPPORTED_FEATURES,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.helpers.aiohttp_client import DATA_CLIENTSESSIO... |
import logging
from kalliope.core.ConfigurationManager import BrainLoader
from kalliope.core.Cortex import Cortex
from kalliope.core.HookManager import HookManager
from kalliope.core.Lifo.LifoManager import LifoManager
from kalliope.core.Models.MatchedSynapse import MatchedSynapse
from kalliope.core.OrderAnalyser imp... |
import unittest
import numpy as np
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 Conv2DActiv
def _add_one(x):
return x + 1
@testing.parameterize(*testing.product({
'dilate': [1,... |
import numpy as np
def check_indices(indices):
"""Check indices parameter."""
if not isinstance(indices, tuple) or len(indices) != 2:
raise ValueError('indices must be a tuple of length 2')
if len(indices[0]) != len(indices[1]):
raise ValueError('Index arrays indices[0] and indices[1] mu... |
import diamond.collector
import json
import urllib2
METRICS_KEYS = ['sendPkgRate',
'recvPkgRate',
'sendAppendRequestCnt',
'recvAppendRequestCnt',
'sendBandwidthRate',
'recvBandwidthRate']
class EtcdCollector(diamond.collector.Collector)... |
import copy as cp
import os.path as op
import numpy as np
from numpy.testing import (assert_array_almost_equal, assert_allclose,
assert_equal)
import pytest
from scipy import linalg
from mne import (compute_proj_epochs, compute_proj_evoked, compute_proj_raw,
pick_types, re... |
from datetime import timedelta
import lupupy.constants as CONST
from homeassistant.components.binary_sensor import DEVICE_CLASSES, BinarySensorEntity
from . import DOMAIN as LUPUSEC_DOMAIN, LupusecDevice
SCAN_INTERVAL = timedelta(seconds=2)
def setup_platform(hass, config, add_entities, discovery_info=None):
... |
from datetime import datetime, timedelta
import json
from homeassistant.components.brother.const import UNIT_PAGES
from homeassistant.const import (
ATTR_DEVICE_CLASS,
ATTR_ENTITY_ID,
ATTR_ICON,
ATTR_UNIT_OF_MEASUREMENT,
DEVICE_CLASS_TIMESTAMP,
PERCENTAGE,
STATE_UNAVAILABLE,
)
from homeass... |
import re
from datetime import datetime
from functools import lru_cache, reduce
from dateutil.parser import ParserError, parse
from django.db.models import Q
from django.utils import timezone
from django.utils.translation import gettext as _
from jellyfish import damerau_levenshtein_distance
from pyparsing import (
... |
import functools
import opt_einsum
# pylint: disable=line-too-long
from tensornetwork.network_operations import check_connected, get_all_edges, get_subgraph_dangling
# pylint: disable=line-too-long
from tensornetwork.network_components import get_all_nondangling, contract_parallel, contract_between
from tensornetwork.... |
import functools
import logging
import os
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import data
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_packages import cassandra
from perfkitbenchmarker.linux_packages import ycsb
FLAGS = flags.FLAGS
BENCHMARK_N... |
import asyncio
import os
import pytest
from redbot import _update_event_loop_policy
from redbot.core import drivers, data_manager
_update_event_loop_policy()
@pytest.fixture(scope="session")
def event_loop(request):
"""Create an instance of the default event loop for entire session."""
loop = asyncio.new_... |
import numpy as np
import spacy
from sklearn.linear_model import LogisticRegression
from scattertext import SampleCorpora, produce_scattertext_explorer
from scattertext.CorpusFromPandas import CorpusFromPandas
from scattertext.Scalers import scale
nlp = spacy.load('en')
convention_df = SampleCorpora.ConventionData20... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker.linux_packages import memcached_server
from perfkitbenchmarker.linux_packages import memtier
FLAGS = flags.FLAGS
flags.DE... |
from datetime import timedelta
import logging
import async_timeout
from pyowm.exceptions.api_call_error import APICallError
from pyowm.exceptions.api_response_error import UnauthorizedError
from homeassistant.components.weather import (
ATTR_FORECAST_CONDITION,
ATTR_FORECAST_PRECIPITATION,
ATTR_FORECAST_... |
import socket
import struct
import select
import sys
from datetime import datetime
from copy import deepcopy
if sys.version_info.major == 2:
# Python 2.7 io.StringIO does not like unicode
from StringIO import StringIO
else:
try:
from io import StringIO
except ImportError:
from cStringI... |
import asyncio
import logging
import os
import aionotify
from evdev import InputDevice, categorize, ecodes, list_devices
import voluptuous as vol
from homeassistant.const import EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__nam... |
import pytest
from homeassistant import data_entry_flow
from homeassistant.components import islamic_prayer_times
from homeassistant.components.islamic_prayer_times.const import CONF_CALC_METHOD, DOMAIN
from tests.async_mock import patch
from tests.common import MockConfigEntry
@pytest.fixture(name="mock_setup", a... |
from requests import HTTPError
from twitch.resources import Channel, Follow, Stream, Subscription, User
from homeassistant.components import sensor
from homeassistant.const import CONF_CLIENT_ID
from homeassistant.setup import async_setup_component
from tests.async_mock import MagicMock, patch
ENTITY_ID = "sensor.c... |
import asyncio
from logging import getLogger
from aiohttp.client_exceptions import ClientResponseError
import async_timeout
from kaiterra_async_client import AQIStandard, KaiterraAPIClient, Units
from homeassistant.const import CONF_API_KEY, CONF_DEVICE_ID, CONF_DEVICES, CONF_TYPE
from homeassistant.helpers.dispatch... |
from homeassistant.exceptions import HomeAssistantError
class HmipcException(HomeAssistantError):
"""Base class for HomematicIP Cloud exceptions."""
class HmipcConnectionError(HmipcException):
"""Unable to connect to the HomematicIP Cloud server."""
class HmipcConnectionWait(HmipcException):
"""Wait ... |
import urllib2
import diamond.collector
from diamond.convertor import time as time_convertor
try:
import json
except ImportError:
import simplejson as json
class PuppetDBCollector(diamond.collector.Collector):
PATHS = {
'memory':
"v2/metrics/mbean/java.lang:type=Memory",
'qu... |
import logging
import os
from absl import flags
from perfkitbenchmarker import data
from perfkitbenchmarker import errors
FLAGS = flags.FLAGS
flags.DEFINE_string(
'aws_credentials_local_path', os.path.join('~', '.aws'),
'Path where the AWS credential files can be found on the local machine.')
flags.DEFINE_... |
from pygal import Pie
def test_donut():
"""Test a donut pie chart"""
chart = Pie(inner_radius=.3, pretty_print=True)
chart.title = 'Browser usage in February 2012 (in %)'
chart.add('IE', 19.5)
chart.add('Firefox', 36.6)
chart.add('Chrome', 36.3)
chart.add('Safari', 4.5)
chart.add('Ope... |
import os
import os.path as op
import shutil
import sys
import numpy as np
import pytest
from pathlib import Path
import mne
from mne.datasets import testing
from mne.io.pick import pick_channels_cov
from mne.utils import (check_random_state, _check_fname, check_fname,
_check_subject, requires... |
from collections import Counter
from dataclasses import dataclass
from typing import Any, Callable, Optional, Union
import aioshelly
from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
from homeassistant.core import callback
from homeassistant.helpers import device_registry, entity
from . import ShellyDev... |
from weblate.trans.management.commands import WeblateLangCommand
class Command(WeblateLangCommand):
help = "updates checks for units"
def handle(self, *args, **options):
translations = {}
for unit in self.iterate_units(*args, **options):
unit.run_checks()
if unit.tran... |
import hangups
from common import run_example
async def sync_recent_conversations(client, _):
user_list, conversation_list = (
await hangups.build_user_conversation_list(client)
)
all_users = user_list.get_all()
all_conversations = conversation_list.get_all(include_archived=True)
print(... |
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 powerdns import PowerDNSCollector
##########################################################################
class TestPowerDN... |
import socket
try:
import json
except ImportError:
import simplejson as json
import diamond.collector
from diamond.collector import str_to_bool
DOTS_TO_UNDERS = {ord(u'.'): u'_'}
class PostfixCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(Postf... |
import numpy as np
from scipy.sparse import csr_matrix, lil_matrix
class CombineDocsIntoDomains(object):
def __init__(self, term_doc_matrix):
'''
Parameters
----------
term_doc_matrix : TermDocMatrix
'''
self.term_doc_matrix = term_doc_matrix
def get_new_term_doc_mat(self, doc_domains, non_text=False)... |
from datetime import timedelta
import arrow
from cryptography import x509
from flask import current_app
from idna.core import InvalidCodepoint
from sqlalchemy import (
event,
Integer,
ForeignKey,
String,
DefaultClause,
func,
Column,
Text,
Boolean,
Index,
)
from sqlalchemy.ext.h... |
from datetime import datetime, timedelta
import os
import time
import pytest
import requests
from vcr import VCR
from subliminal import __short_version__
from subliminal.video import Episode
from subliminal.refiners.tvdb import TVDBClient, refine, series_re
vcr = VCR(path_transformer=lambda path: path + '.yaml',
... |
from copy import deepcopy
import numpy as np
from scipy import linalg
from .. import pick_channels_forward, EvokedArray, SourceEstimate
from ..io.constants import FIFF
from ..utils import logger, verbose
from ..forward.forward import convert_forward_solution
from ..minimum_norm import apply_inverse
from ..source_es... |
from homeassistant.const import ATTR_ATTRIBUTION
from homeassistant.core import callback
from homeassistant.helpers.restore_state import RestoreEntity
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import (
ATTR_BYTES_RECEIVED,
ATTR_BYTES_SENT,
ATTR_SERVER_COUNTRY,
... |
import logging
from vine.utils import wraps
from kombu.log import get_logger
__all__ = ('setup_logging', 'Logwrapped')
def setup_logging(loglevel=logging.DEBUG, loggers=None):
"""Setup logging to stdout."""
loggers = ['kombu.connection', 'kombu.channel'] if not loggers else loggers
for logger_name in ... |
from unittest import TestCase
import numpy as np
from scattertext.termscoring.CornerScore import CornerScore
class TestCornerScore(TestCase):
def test_get_scores(self):
cat_counts, not_cat_counts = self._get_counts()
scores = CornerScore.get_scores(cat_counts, not_cat_counts)
np.testing.assert_almost_equal(... |
from collections import Counter
from scattertext.features.FeatsFromSpacyDoc import FeatsFromSpacyDoc
class UseFullDocAsFeature(FeatsFromSpacyDoc):
def get_feats(self, doc):
'''
Parameters
----------
doc, Spacy Docs
Returns
-------
Counter str -> count
... |
from aiohttp import WSMsgType
import voluptuous as vol
from homeassistant.components.websocket_api import const, messages
from tests.async_mock import Mock, patch
async def test_invalid_message_format(websocket_client):
"""Test sending invalid JSON."""
await websocket_client.send_json({"type": 5})
msg... |
from __future__ import absolute_import, unicode_literals
import logging
import os
import shlex
import subprocess
import sys
from . import exc
from ._compat import console_to_str
logger = logging.getLogger(__name__)
PY2 = sys.version_info[0] == 2
def run_before_script(script_file, cwd=None):
"""Function to wr... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from perfkitbenchmarker import disk
from perfkitbenchmarker import errors
from perfkitbenchmarker import providers
from perfkitbenchmarker import virtual_machine
from perfkitbenchmarker import vm_util
from perf... |
from collections import defaultdict
import logging
import pytest
from homeassistant.components import logger
from homeassistant.components.logger import LOGSEVERITY
from homeassistant.setup import async_setup_component
from tests.async_mock import Mock, patch
HASS_NS = "unused.homeassistant"
COMPONENTS_NS = f"{HAS... |
from homeassistant.const import STATE_ON
from .util import async_init_integration
async def test_create_binary_sensors(hass):
"""Test creation of binary_sensors."""
await async_init_integration(hass)
state = hass.states.get("binary_sensor.happy_place_myq_gateway")
assert state.state == STATE_ON
... |
import unittest
import numpy as np
import pytest
from chainer import testing
from chainer.datasets import TupleDataset
from chainercv.datasets import MixUpSoftLabelDataset
from chainercv.datasets import SiameseDataset
from chainercv.utils.testing.assertions.assert_is_image import assert_is_image
N = 15
@testing... |
import logging
from homeassistant.util import slugify
from . import DOMAIN as BMW_DOMAIN
_LOGGER = logging.getLogger(__name__)
def setup_scanner(hass, config, see, discovery_info=None):
"""Set up the BMW tracker."""
accounts = hass.data[BMW_DOMAIN]
_LOGGER.debug("Found BMW accounts: %s", ", ".join([a.... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import flags
from absl.testing import absltest
from absl.testing import flagsaver
flags.DEFINE_string('flagsaver_test_flag0', 'unchanged0', 'flag to test with')
flags.DEFINE_string('flagsaver_test_f... |
import unittest.mock
import pytest
from PyQt5.QtCore import QUrl
from qutebrowser.browser import urlmarks
@pytest.fixture
def bm_file(config_tmpdir):
bm_dir = config_tmpdir / 'bookmarks'
bm_dir.mkdir()
bm_file = bm_dir / 'urls'
return bm_file
def test_init(bm_file, fake_save_manager):
bm_file... |
import ipaddress
import fnmatch
import urllib.parse
from typing import Any, Optional, Tuple
from PyQt5.QtCore import QUrl
from qutebrowser.utils import utils, qtutils
class ParseError(Exception):
"""Raised when a pattern could not be parsed."""
class UrlPattern:
"""A Chromium-like URL matching pattern.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.