text stringlengths 213 32.3k |
|---|
import unittest
import logging
import os
import io
import sys
import random
import string
import mmap
import tempfile
from acdcli.api import client, content, common
from acdcli.api.common import RequestError
from acdcli.utils import hashing
logging.basicConfig(level=logging.INFO)
path = os.path.join(os.path.dirname(... |
import logging
from aiounifi.api import SOURCE_EVENT
from aiounifi.events import (
WIRED_CLIENT_BLOCKED,
WIRED_CLIENT_UNBLOCKED,
WIRELESS_CLIENT_BLOCKED,
WIRELESS_CLIENT_UNBLOCKED,
)
from homeassistant.components.switch import DOMAIN, SwitchEntity
from homeassistant.core import callback
from homeassi... |
import logging
import unittest
import uuid
import boto3
import moto
from smart_open import open
BUCKET_NAME = 'test-smartopen'
KEY_NAME = 'test-key'
logger = logging.getLogger(__name__)
@moto.mock_s3
def setUpModule():
'''Called once by unittest when initializing this module. Sets up the
test S3 bucke... |
import logging
import re
from pexpect import pxssh
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT, CONF_USERNAME
import homeassistant.helpers.config_validation as ... |
import numpy as np
from examples.fft import fft
import tensornetwork as tn
def test_fft():
n = 3
initial_state = [complex(0)] * (1 << n)
initial_state[1] = 1j
initial_state[5] = -1
initial_node = tn.Node(np.array(initial_state).reshape((2,) * n))
fft_out = fft.add_fft([initial_node[k] for k in range(n)]... |
import logging
import homeassistant.components.alarm_control_panel as alarm
from homeassistant.components.alarm_control_panel.const import (
SUPPORT_ALARM_ARM_AWAY,
SUPPORT_ALARM_ARM_HOME,
SUPPORT_ALARM_ARM_NIGHT,
)
from homeassistant.const import (
STATE_ALARM_ARMED_AWAY,
STATE_ALARM_ARMED_CUSTOM... |
import logging
from pyhap.const import CATEGORY_SWITCH, CATEGORY_TELEVISION
from homeassistant.components.media_player import (
ATTR_INPUT_SOURCE,
ATTR_INPUT_SOURCE_LIST,
ATTR_MEDIA_VOLUME_LEVEL,
ATTR_MEDIA_VOLUME_MUTED,
DOMAIN,
SERVICE_SELECT_SOURCE,
SUPPORT_PAUSE,
SUPPORT_PLAY,
... |
from __future__ import absolute_import, print_function
import cgi
import mimetypes
import os
import posixpath
import re
import shutil
from six import StringIO
from six.moves import BaseHTTPServer
from six.moves.urllib.parse import quote, unquote
__version__ = "0.1"
__all__ = ["SimpleHTTPRequestHandler"]
__author__ ... |
from enum import Enum
import pytest
from homeassistant.components import alarm_control_panel
from homeassistant.components.ness_alarm import (
ATTR_CODE,
ATTR_OUTPUT_ID,
CONF_DEVICE_PORT,
CONF_ZONE_ID,
CONF_ZONE_NAME,
CONF_ZONES,
DOMAIN,
SERVICE_AUX,
SERVICE_PANIC,
)
from homeassi... |
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker.linux_packages import speccpu
from perfkitbenchmarker.linux_packages import speccpu2006
FLAGS = flags.FLAGS
_SPECINT_BENCHMARKS = frozenset([
'perlbench', 'bzip2', 'gcc', 'mcf', 'gobmk', 'hmmer', 'sjeng',
'libquantum', 'h2... |
import pytest
import yarl
import homeassistant.components.media_player as media_player
from homeassistant.components.media_player.const import (
DOMAIN as DOMAIN_MP,
SERVICE_PLAY_MEDIA,
)
import homeassistant.components.notify as notify
import homeassistant.components.tts as tts
from homeassistant.config impo... |
import io
import os
import pytest
import nikola.plugins.command.init
from nikola import __main__
from .helper import append_config, cd
from .test_demo_build import prepare_demo_site
from .test_empty_build import ( # NOQA
test_archive_exists,
test_avoid_double_slash_in_rss,
test_check_files,
test_ch... |
import os
import unittest
import mock
from perfkitbenchmarker import test_util
from perfkitbenchmarker.linux_benchmarks import mnist_benchmark
from perfkitbenchmarker.sample import Sample
class MnistBenchmarkTestCase(unittest.TestCase,
test_util.SamplesTestMixin):
def setUp(self):
... |
import numpy as np
from numpy.testing import assert_array_equal
import pytest
from mne.utils import requires_sklearn
from mne.decoding.time_frequency import TimeFrequency
@requires_sklearn
def test_timefrequency():
"""Test TimeFrequency."""
from sklearn.base import clone
# Init
n_freqs = 3
freqs... |
from homeassistant.core import callback
from homeassistant.helpers.device_registry import CONNECTION_ZIGBEE
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import Entity
from .const import DOMAIN as DECONZ_DOMAIN
class DeconzBase:
"""Common base for deconz... |
from gi.repository import GObject, Gtk, GtkSource
@Gtk.Template(resource_path='/org/gnome/meld/ui/findbar.ui')
class FindBar(Gtk.Grid):
__gtype_name__ = 'FindBar'
find_entry = Gtk.Template.Child()
find_next_button = Gtk.Template.Child()
find_previous_button = Gtk.Template.Child()
match_case = G... |
from lxml.etree import XPath, ElementBase
from lxml.html import fromstring, XHTML_NAMESPACE
from lxml.html import _forms_xpath, _options_xpath, _nons, _transform_result
from lxml.html import defs
import copy
try:
basestring
except NameError:
# Python 3
basestring = str
__all__ = ['FormNotFound', 'fill_fo... |
import collections
from typing import Callable, Dict, List, Set, Tuple, Union
import attr
import zigpy.profiles.zha
import zigpy.profiles.zll
import zigpy.zcl as zcl
from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR
from homeassistant.components.climate import DOMAIN as CLIMATE
from homeassi... |
import os
import subprocess
import sys
import zipfile
def main(argv):
if len(argv) != 2:
sys.exit('Usage: %s <outfile>' % argv[0])
zip_file_path = argv[1]
version = subprocess.check_output(('pkb.py', '--version')).rstrip()
with zipfile.ZipFile(zip_file_path, 'w') as zip_file:
for dir_path, _, file_... |
from typing import List
import voluptuous as vol
from homeassistant.components.automation import AutomationActionType
from homeassistant.components.device_automation import (
TRIGGER_BASE_SCHEMA,
toggle_entity,
)
from homeassistant.components.homeassistant.triggers import (
numeric_state as numeric_state... |
import logging
import asyncio
from typing import Union, List, Literal
from datetime import timedelta
from copy import copy
import contextlib
import discord
from redbot.core import Config, checks, commands
from redbot.core.utils import AsyncIter
from redbot.core.utils.chat_formatting import pagify, box
from redbot.cor... |
from .lexer import Token
###{standalone
class Indenter:
def __init__(self):
self.paren_level = None
self.indent_level = None
assert self.tab_len > 0
def handle_NL(self, token):
if self.paren_level > 0:
return
yield token
indent_str = token.rsplit(... |
import time
import unittest
import object_storage_api_tests # noqa: importing for flags
import object_storage_interface
import validate_service
class MockObjectStorageService(object_storage_interface.ObjectStorageServiceBase): # noqa
def __init__(self):
self.bucket = None
self.objects = {}
def _CheckB... |
from __future__ import unicode_literals
from lib.data.data import pystrs
from lib.fun.decorator import magic
from lib.fun.fun import range_compatible
def pid6_magic(*args):
"""chinese id card last 6 digit"""
posrule = lambda _: str(_) if _ >= 10 else "0" + str(_)
# day
value1314 = " ".join(posrule(... |
from flexx import flx
from flexxamples.demos.drawing import Drawing
from flexxamples.howtos.splitters import Split
from flexxamples.demos.twente import Twente
class MultiApp(flx.TabLayout):
def init(self):
Drawing(title='Drawing')
Split(title='Split')
Twente(title='Twente')
if __name__... |
import os
import posixpath
import re
from absl import flags
from perfkitbenchmarker import errors
from perfkitbenchmarker import linux_packages
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_packages import amdblis
from perfkitbenchmarker.linux_packages import openblas
PACKAGE_NAME = 'hpcc'
HPC... |
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.vacuum import DOMAIN
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_component
from tests.common import (
MockConfigEntry,
assert_lists_same,
async_get_device... |
import logging
import threading
from flask import jsonify
from flask import request
from flask_cors import CORS
from kalliope._version import version_str
from kalliope.core.ConfigurationManager import SettingLoader
from kalliope.core.RestAPI.utils import requires_auth
from kalliope.core.RestAPI.views.neurons_view im... |
from os import path as path
import numpy as np
from ...utils import _check_option, get_subjects_dir, _check_fname
from ...surface import (complete_surface_info, read_surface, read_curvature,
_read_patch)
class Surface(object):
"""Container for a brain surface.
It is used for storing... |
import unittest
from trashcli.empty import EmptyCmd
from mock import Mock, call
class TestTrashEmptyCmd(unittest.TestCase):
def setUp(self):
self.empty_all_trashdirs = Mock()
self.empty_trashdir = Mock()
self.cmd = EmptyCmd(None, None, None, None, None, None, None, None, None)
s... |
import json
import shlex
import subprocess
import sys
import pkg_resources
import requests
RELEASES_URL = "https://api.github.com/repos/{repo}/releases"
def run_command(cmd):
"""
Run a command line (with no shell).
Returns a tuple:
bool: true if the command succeeded.
str: the output o... |
import os
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('baz')
def test_hostname(host):
assert 'instance-2' == host.check_output('hostname -s')
def test_etc_molecule_directory(host):
f = host.file... |
import arrow
from sqlalchemy import func
from lemur import database
from lemur.common.utils import truthiness
from lemur.endpoints.models import Endpoint, Policy, Cipher
from lemur.extensions import metrics
def get_all():
"""
Get all endpoints that are currently in Lemur.
:rtype : List
:return:
... |
import os
import os.path
import sys
import shutil
import contextlib
import enum
import argparse
from typing import Iterator, Optional
from PyQt5.QtCore import QStandardPaths
from PyQt5.QtWidgets import QApplication
from qutebrowser.utils import log, debug, message, utils
# The cached locations
_locations = {}
cla... |
import numpy as np
from tensornetwork.block_sparse.utils import intersect, unique
from typing import (List, Optional, Type, Any, Union, Callable)
#TODO (mganahl): clean up implementation of identity charges
class BaseCharge:
"""
Base class for charges of BlockSparseTensor. All user defined charges
should be d... |
import pytest
from mock import create_autospec, sentinel
from pymongo.database import Database
from pymongo.errors import PyMongoError, OperationFailure
from arctic import auth
def test_authenticate():
db = create_autospec(Database)
db.authenticate.return_value = sentinel.ret
assert auth.authenticate(db... |
import unittest
import numpy as np
from chainer.backends import cuda
from chainer import testing
from chainer.testing import attr
from chainercv.experimental.links.model.fcis import ProposalTargetCreator
from chainercv.utils import generate_random_bbox
from chainercv.utils import mask_to_bbox
class TestProposalT... |
import unittest
from trashcli.put import TrashPutReporter
class TestTrashPutReporter(unittest.TestCase):
def test_it_should_record_failures(self):
reporter = TrashPutReporter(self)
assert False == reporter.some_file_has_not_be_trashed
reporter.unable_to_trash_file('a file')
ass... |
import unittest
import os.path
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.basemap import Basemap
class TestMatplotlib(unittest.TestCase):
def test_plot(self):
plt.plot(np.linspace(0,1,50), np.random.rand(50))
plt.savefig("plot1.png")
self.assertTrue(os.path.isf... |
from cms.plugin_rendering import ContentRenderer
from cms.models.placeholdermodel import Placeholder
from cms.templatetags.cms_tags import RenderPlaceholder as DefaultRenderPlaceholder
from django import template
from django.contrib.auth.models import AnonymousUser
from django.http.request import HttpRequest
from djan... |
from datetime import timedelta
import logging
from typing import Optional
from aio_geojson_nsw_rfs_incidents import NswRuralFireServiceIncidentsFeedManager
import voluptuous as vol
from homeassistant.components.geo_location import PLATFORM_SCHEMA, GeolocationEvent
from homeassistant.const import (
ATTR_ATTRIBUTI... |
import pkgutil
from scattertext.Common import SEMIOTIC_SQUARE_HTML_PATH
class ClickableTerms:
@staticmethod
def get_clickable_lexicon(lexicon, plot_interface='plotInterface'):
out = []
for term in lexicon:
clickable_term = ClickableTerms.get_clickable_term(term, plot_interface)
out.append(clickable_term... |
import pytest
from zigpy.config import CONF_DEVICE, CONF_DEVICE_PATH
from homeassistant.components.zha.core.const import (
CONF_BAUDRATE,
CONF_RADIO_TYPE,
CONF_USB_PATH,
DOMAIN,
)
from homeassistant.const import MAJOR_VERSION, MINOR_VERSION
from homeassistant.setup import async_setup_component
from t... |
import asyncio
from Plugwise_Smile.Smile import Smile
from homeassistant.components.plugwise import DOMAIN
from homeassistant.components.plugwise.gateway import async_unload_entry
from homeassistant.config_entries import (
ENTRY_STATE_SETUP_ERROR,
ENTRY_STATE_SETUP_RETRY,
)
from tests.common import AsyncMoc... |
import re
from absl import flags
from perfkitbenchmarker import flag_util
from perfkitbenchmarker import regex_util
NVIDIA_DRIVER_LOCATION_BASE = 'https://us.download.nvidia.com/tesla'
NVIDIA_TESLA_K80 = 'k80'
NVIDIA_TESLA_P4 = 'p4'
NVIDIA_TESLA_P100 = 'p100'
NVIDIA_TESLA_V100 = 'v100'
NVIDIA_TESLA_T4 = 't4'
NVIDIA... |
import eventlet
from kombu import Connection
eventlet.monkey_patch()
def send_many(n):
#: Create connection
#: If hostname, userid, password and virtual_host is not specified
#: the values below are the default, but listed here so it can
#: be easily changed.
with Connection('amqp://guest:gues... |
from datetime import timedelta
from homeassistant.components.streamlabswater import DOMAIN as STREAMLABSWATER_DOMAIN
from homeassistant.const import VOLUME_GALLONS
from homeassistant.helpers.entity import Entity
from homeassistant.util import Throttle
DEPENDENCIES = ["streamlabswater"]
WATER_ICON = "mdi:water"
MIN_... |
import sys
__author__ = "github.com/casperdcl"
__all__ = ['tqdm_pandas']
def tqdm_pandas(tclass, *targs, **tkwargs):
"""
Registers the given `tqdm` instance with
`pandas.core.groupby.DataFrameGroupBy.progress_apply`.
It will even close() the `tqdm` instance upon completion.
Parameters
-----... |
import numpy as np
import pytest
import itertools
from tensornetwork.block_sparse.charge import (U1Charge, charge_equal,
fuse_ndarray_charges, BaseCharge)
from tensornetwork.block_sparse.utils import (fuse_ndarrays, _get_strides,
... |
from __future__ import print_function
import argparse
import base64
import os
_stash = globals()['_stash']
try:
import pyaes
except ImportError:
print('Installing Required packages...')
_stash('pip install pyaes')
import pyaes
class Crypt(object):
def __init__(self, in_filename, out_filename=Non... |
from unittest import TestCase
from scattertext.FeatureOuput import FeatureLister
from scattertext.test.test_termDocMatrixFactory import build_hamlet_jz_corpus_with_meta
class TestFeatureList(TestCase):
def test_main(self):
tdm = build_hamlet_jz_corpus_with_meta()
features = FeatureLister(tdm._mX,
... |
import sys, os, re, json, argparse, time, pytz
import console
from datetime import datetime, timedelta
from difflib import unified_diff, ndiff
#_____________________________________________________
def argue():
parser = argparse.ArgumentParser()
parser.add_argument('-v', '--verbose', action='store_true')
... |
import boto3
from flask import current_app
from flask_mail import Message
from lemur.extensions import smtp_mail
from lemur.exceptions import InvalidConfiguration
from lemur.plugins.bases import ExpirationNotificationPlugin
from lemur.plugins import lemur_email as email
from lemur.plugins.lemur_email.templates.conf... |
import sys
ALIASES = {'-h': 'help', '--help': 'help',
'--version': 'version',
}
class CLI:
""" Command line interface class. Commands are simply defined as methods.
"""
def __init__(self, args=None):
if args is None:
return
command = args[0] if args else... |
import json
import os
import responses
from django.conf import settings
from django.core import mail
from django.core.checks import Critical
from django.core.serializers.json import DjangoJSONEncoder
from django.test.utils import override_settings
from django.urls import reverse
from django.utils import timezone
fro... |
import logging
from typing import Any, Dict, Optional
from urllib.parse import urlparse
from directv import DIRECTV, DIRECTVError
import voluptuous as vol
from homeassistant.components.ssdp import ATTR_SSDP_LOCATION, ATTR_UPNP_SERIAL
from homeassistant.config_entries import CONN_CLASS_LOCAL_POLL, ConfigFlow
from hom... |
import asyncio
from homeassistant.components import camera, microsoft_face as mf
from homeassistant.components.microsoft_face import (
ATTR_CAMERA_ENTITY,
ATTR_GROUP,
ATTR_PERSON,
DOMAIN,
SERVICE_CREATE_GROUP,
SERVICE_CREATE_PERSON,
SERVICE_DELETE_GROUP,
SERVICE_DELETE_PERSON,
SERV... |
import asyncio
import contextlib
import platform
import sys
import codecs
import logging
import traceback
from datetime import datetime, timedelta
import aiohttp
import discord
import pkg_resources
from colorama import Fore, Style, init
from pkg_resources import DistributionNotFound
from redbot.core import data_manag... |
from contextlib import suppress
import numpy as np
import pandas as pd
import pytest
import xarray as xr
from xarray.coding import variables
from xarray.conventions import decode_cf_variable, encode_cf_variable
from . import assert_equal, assert_identical, requires_dask
with suppress(ImportError):
import dask.... |
import voluptuous as vol
from homeassistant.auth.providers import homeassistant as auth_ha
from homeassistant.components import websocket_api
from homeassistant.components.websocket_api import decorators
from homeassistant.exceptions import Unauthorized
async def async_setup(hass):
"""Enable the Home Assistant ... |
from copy import deepcopy
import json
import unittest
import requests_mock
from homeassistant import setup
import homeassistant.components.vultr as vultr
from tests.async_mock import patch
from tests.common import get_test_home_assistant, load_fixture
VALID_CONFIG = {"vultr": {"api_key": "ABCDEFG1234567"}}
class... |
import math
import struct
from openrazer_daemon.dbus_services import endpoint
@endpoint('razer.device.power', 'getBattery', out_sig='d')
def get_battery(self):
"""
Get mouse's battery level
"""
self.logger.debug("DBus call get_battery")
driver_path = self.get_driver_path('charge_level')
wit... |
from kombu.utils.objects import cached_property
class test_cached_property:
def test_deleting(self):
class X:
xx = False
@cached_property
def foo(self):
return 42
@foo.deleter # noqa
def foo(self, value):
sel... |
from pyaehw4a1.aehw4a1 import AehW4a1
from homeassistant import config_entries
from homeassistant.helpers import config_entry_flow
from .const import DOMAIN
async def _async_has_devices(hass):
"""Return if there are devices that can be discovered."""
aehw4a1_ip_addresses = await AehW4a1().discovery()
r... |
from __future__ import unicode_literals
import logging
import unittest
import smart_open
GZIP_MAGIC = b'\x1f\x8b'
BASE_URL = ('https://raw.githubusercontent.com/RaRe-Technologies/smart_open/'
'master/smart_open/tests/test_data/')
class ReadTest(unittest.TestCase):
def test_read_text(self):
... |
from aiohttp import ClientError
from homeassistant.components.nightscout.const import DOMAIN
from homeassistant.config_entries import (
ENTRY_STATE_LOADED,
ENTRY_STATE_NOT_LOADED,
ENTRY_STATE_SETUP_RETRY,
)
from homeassistant.const import CONF_URL
from tests.async_mock import patch
from tests.common impo... |
import datetime
class NeverExpires(object):
def expired(self):
return False
class Timer(object):
"""
A simple timer that will indicate when an expiration time has passed.
"""
def __init__(self, expiration):
'Create a timer that expires at `expiration` (UTC datetime)'
sel... |
import logging
from envoy_reader.envoy_reader import EnvoyReader
import requests
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_IP_ADDRESS,
CONF_MONITORED_CONDITIONS,
CONF_NAME,
CONF_PASSWORD,
CONF_USERNAME,
ENERGY_W... |
import logging
import time
from threading import Event, Thread
import pip
from .guns import LogGun, SqlGun, CustomGun, HttpGun, ScenarioGun, UltimateGun
from .reader import BfgReader, BfgStatsReader
from .widgets import BfgInfoWidget
from ..Phantom import PhantomReader, string_to_df
from .worker import BFGMultiproce... |
import asyncio
from datetime import timedelta
import logging
from typing import Any, Dict, List
from pyvizio.const import APPS
from pyvizio.util import gen_apps_list_from_url
import voluptuous as vol
from homeassistant.components.media_player import DEVICE_CLASS_TV
from homeassistant.config_entries import ENTRY_STAT... |
from __future__ import division
from builtins import range
from .._externals.srm import SRM
from .procrustes import procrustes
import numpy as np
from .format_data import format_data as formatter
from .._shared.helpers import memoize
import warnings
@memoize
def align(data, align='hyper', normalize=None, ndims=None, ... |
import abc
import hashlib
import logging
from threading import RLock
import numpy as np
import pandas as pd
from bson import Binary
from arctic._config import ARCTIC_AUTO_EXPAND_CHUNK_SIZE
from arctic.serialization.numpy_records import PandasSerializer
from .._compression import compress
from .._config import MAX_DO... |
from io import BytesIO
from vcr.filters import (
remove_headers,
replace_headers,
remove_query_parameters,
replace_query_parameters,
remove_post_data_parameters,
replace_post_data_parameters,
decode_response,
)
from vcr.request import Request
import gzip
import json
from unittest import moc... |
from flexx import flx
class Cookies(flx.PyComponent):
def init(self):
with flx.Widget():
flx.Label(text='Refreshing the page should '
'maintain the value of the line edit.')
self.edit = flx.LineEdit(placeholder_text='username',
... |
from homeassistant.core import callback
from homeassistant.helpers.storage import Store
from .const import DOMAIN
ENTITY_MAP_STORAGE_KEY = f"{DOMAIN}-entity-map"
ENTITY_MAP_STORAGE_VERSION = 1
ENTITY_MAP_SAVE_DELAY = 10
class EntityMapStorage:
"""
Holds a cache of entity structure data from a paired HomeKi... |
import numpy as np
from jax import config
import pytest
import tensornetwork
from tensornetwork.linalg import linalg
import tensornetwork.linalg.initialization
from tensornetwork import backends, backend_contextmanager
from tensornetwork.tests import testing_utils
from tensornetwork.block_sparse.index import Index
fro... |
import asyncio
import voluptuous as vol
from homeassistant.const import ATTR_GPS_ACCURACY, STATE_HOME
from homeassistant.helpers import discovery
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.event import async_track_utc_time_change
from homeassistant.helpers.typing import ConfigTyp... |
import unittest
from unittest.mock import patch, Mock
from flask import Flask
from lemur.plugins.lemur_acme import plugin, powerdns
class TestPowerdns(unittest.TestCase):
@patch("lemur.plugins.lemur_acme.plugin.dns_provider_service")
def setUp(self, mock_dns_provider_service):
self.ACMEIssuerPlugin ... |
from datetime import timedelta
import logging
from pylaunches.api import Launches
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import ATTR_ATTRIBUTION, CONF_NAME
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassist... |
from flasgger import Swagger
from flask import Flask, jsonify
app = Flask(__name__)
app.config['SWAGGER'] = {
'title': 'Vendor extension test',
'uiversion': 2,
'x-groupTag': 'Test',
}
swag = Swagger(app)
def test_swag(client, specs_data):
"""
This test is runs automatically in Travis CI
:pa... |
import os
import sys
import subprocess
import logging
import time
import platform
import re
from functools import partial
from plumbum.path.local import LocalPath, LocalWorkdir
from tempfile import mkdtemp
from contextlib import contextmanager
from plumbum.path.remote import RemotePath
from plumbum.commands import Com... |
import logging
import typing
import voluptuous as vol
from homeassistant.const import (
ATTR_EDITABLE,
CONF_ICON,
CONF_ID,
CONF_NAME,
SERVICE_RELOAD,
)
from homeassistant.core import callback
from homeassistant.helpers import collection
import homeassistant.helpers.config_validation as cv
from ho... |
from behave import given
from behave import then
from behave import when
from docker.errors import APIError
from paasta_tools.utils import _run
from paasta_tools.utils import get_docker_client
@given("Docker is available")
def docker_is_available(context):
docker_client = get_docker_client()
assert docker_c... |
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.typing import HomeAssistantType
from .const import SIGNAL_PANEL_MESSAGE
async def async_setup_entry(
hass: HomeAssistantType, entry: ConfigEntry, async_add_entities
):
"""Set up fo... |
import datetime
import os
import sys
sys.path = [os.path.abspath(os.path.dirname(__file__))] + sys.path
sys.path = [os.path.abspath(os.path.dirname(os.path.dirname(__file__)))] + sys.path
from auto_ml import Predictor, __version__ as auto_ml_version
from auto_ml.utils_models import load_ml_model
import dill
import nu... |
from unittest import TestCase
from scattertext.test.test_semioticSquare import get_test_semiotic_square
from scattertext.viz.HTMLSemioticSquareViz import HTMLSemioticSquareViz
class TestHTMLSemioticSquareViz(TestCase):
def test_get_html(self):
semsq = get_test_semiotic_square()
html_default = HTMLSemioticSquar... |
import asyncio
import logging
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_LOCK,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNLOCKED,
)
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
f... |
from flexx.util.testing import run_tests_if_main, skipif, skip, raises
from flexx.event.both_tester import run_in_both, StdoutMismatchError
from flexx import event
loop = event.loop
logger = event.logger
def this_is_js():
return False
class Person(event.Component):
first_name = event.StringProp('John', ... |
from typing import Optional
from aioesphomeapi import CoverInfo, CoverOperation, CoverState
from homeassistant.components.cover import (
ATTR_POSITION,
ATTR_TILT_POSITION,
SUPPORT_CLOSE,
SUPPORT_CLOSE_TILT,
SUPPORT_OPEN,
SUPPORT_OPEN_TILT,
SUPPORT_SET_POSITION,
SUPPORT_SET_TILT_POSITI... |
import homeassistant.components.image_processing as ip
from homeassistant.const import ATTR_ENTITY_PICTURE
from homeassistant.core import callback
from homeassistant.setup import setup_component
from tests.async_mock import MagicMock, PropertyMock, patch
from tests.common import assert_setup_component, get_test_home_... |
import errno
import mimetypes
import socket
import sys
from unittest import mock
import urllib.parse
from http.client import HTTPConnection
import cherrypy
from cherrypy._cpcompat import HTTPSConnection
from cherrypy.test import helper
def is_ascii(text):
"""
Return True if the text encodes as ascii.
"... |
import os
import subprocess
from itertools import chain
from typing import List, Optional, Tuple
from django.core.exceptions import ValidationError
from django.utils.functional import cached_property
from django.utils.translation import gettext as _
from weblate.addons.events import (
EVENT_COMPONENT_UPDATE,
... |
from contextlib import contextmanager
from distutils.version import LooseVersion
from functools import partial, wraps
import os
import inspect
from io import StringIO
from shutil import rmtree
import sys
import tempfile
import traceback
from unittest import SkipTest
import warnings
import numpy as np
from numpy.testi... |
import re
class MountEntry(object):
"""
Represents a mount entry (device file, mount point and file system type)
"""
def __init__(self, dev, point, fstype, options):
self.dev = dev
self.point = point
self.fstype = fstype
self.options = options.split(",")
def __st... |
import logging
#
# Prevent regression of #474 and #475
#
logger = logging.getLogger(__name__)
logger.addHandler(logging.NullHandler())
from smart_open import version # noqa: E402
from .smart_open_lib import open, parse_uri, smart_open, register_compressor # noqa: E402
_WARNING = """smart_open.s3_iter_bucket is de... |
from copy import deepcopy
DEFAULTS = dict(
color=dict(mag='darkblue', grad='b', eeg='k', eog='k', ecg='m', emg='k',
ref_meg='steelblue', misc='k', stim='k', resp='k', chpi='k',
exci='k', ias='k', syst='k', seeg='saddlebrown', dipole='k',
gof='k', bio='k', ecog='k', hbo... |
import os
import pickle
import time
from hashlib import sha256
from radicale import pathutils, storage
from radicale.log import logger
class CollectionCacheMixin:
def _clean_cache(self, folder, names, max_age=None):
"""Delete all ``names`` in ``folder`` that are older than ``max_age``.
"""
... |
import os
import posixpath
import time
from http import client
import pkg_resources
from radicale import httputils, pathutils, web
from radicale.log import logger
MIMETYPES = {
".css": "text/css",
".eot": "application/vnd.ms-fontobject",
".gif": "image/gif",
".html": "text/html",
".js": "applica... |
from django.test import SimpleTestCase
from translate.misc.multistring import multistring
from weblate.trans.util import (
cleanup_path,
cleanup_repo_url,
get_string,
translation_percent,
)
class HideCredentialsTest(SimpleTestCase):
def test_http(self):
self.assertEqual(
clea... |
from pylatex import Document
import pylatex.config as cf
def test():
assert type(cf.active) == cf.Default
cf.active = cf.Version1()
assert cf.active.indent
assert Document()._indent
cf.active = cf.Version1(indent=False)
assert not cf.active.indent
assert not Document()._indent
with ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.