text stringlengths 213 32.3k |
|---|
from datetime import datetime
from functools import partial
from json import JSONEncoder, dumps
import math
import os
import sys
from tempfile import mkdtemp
import unittest
import pytest
from homeassistant.core import Event, State
from homeassistant.exceptions import HomeAssistantError
from homeassistant.util.json ... |
from typing import Optional, Sequence
from pysmartthings import Attribute, Capability
from homeassistant.components.switch import SwitchEntity
from . import SmartThingsEntity
from .const import DATA_BROKERS, DOMAIN
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Add switches for a conf... |
import os
import sys
import time
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)),
'snmp'))
from snmp import SNMPCollector as parent_SNMPCollector
from diamond.metric import Metric
class SNMPRawCollector(parent_SNMPCollector):
def process_config(self):
... |
import unittest
import numpy as np
import numpy.testing as np_test
from pgmpy.factors.distributions import GaussianDistribution as GD
class TestGDInit(unittest.TestCase):
def test_class_init(self):
phi1 = GD(
["x1", "x2", "x3"],
np.array([[1], [-3], [4]]),
np.array([... |
import logging
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_NAME, CONF_UNIT_OF_MEASUREMENT
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
import homeassistant.util.dt as dt_util
_LOGGER... |
import pytest
boto = pytest.importorskip("boto")
import boto # NOQA
import boto.iam # NOQA
from boto.s3.connection import S3Connection # NOQA
from boto.s3.key import Key # NOQA
from configparser import DuplicateSectionError # NOQA
import vcr # NOQA
def test_boto_stubs(tmpdir):
with vcr.use_cassette(str(t... |
import logging
from typing import Dict
from typing import Iterable
from typing import List
from typing import Tuple
from typing import Type
from service_configuration_lib import read_service_configuration
from paasta_tools import utils
from paasta_tools.utils import deep_merge_dictionaries
from paasta_tools.utils im... |
import datetime
from homeassistant.components.switch import SwitchEntity
import homeassistant.util.dt as dt_util
from .const import DOMAIN, DOOR_STATION, DOOR_STATION_INFO
from .entity import DoorBirdEntity
IR_RELAY = "__ir_light__"
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set u... |
import unittest
import numpy as np
import pandas as pd
import datashader as ds
import datashader.transfer_functions as tf
class TestDatashader(unittest.TestCase):
# based on https://github.com/pyviz/datashader/blob/master/datashader/tests/test_pipeline.py
def test_pipeline(self):
df = pd.DataFrame({
... |
from aiofreepybox.exceptions import (
AuthorizationError,
HttpRequestError,
InvalidTokenError,
)
import pytest
from homeassistant import data_entry_flow
from homeassistant.components.freebox.const import DOMAIN
from homeassistant.config_entries import SOURCE_DISCOVERY, SOURCE_IMPORT, SOURCE_USER
from home... |
import requests.exceptions
from requests_mock import ANY
from upcloud_api import UpCloudAPIError
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.upcloud.const import DOMAIN
from homeassistant.const import CONF_PASSWORD, CONF_SCAN_INTERVAL, CONF_USERNAME
from tests.common impor... |
import pytest
from homeassistant.components.frontend import DOMAIN
from homeassistant.setup import async_setup_component
@pytest.fixture(autouse=True)
def setup_frontend(hass):
"""Fixture to setup the frontend."""
hass.loop.run_until_complete(async_setup_component(hass, "frontend", {}))
async def test_get... |
import pytest
import nikola.utils
from nikola import shortcodes
@pytest.mark.parametrize(
"template, expected_result",
[
("test({{% noargs %}})", "test(noargs success!)"),
(
"test({{% noargs %}}\\hello world/{{% /noargs %}})",
"test(noargs \\hello world/ success!)",
... |
import asyncio
from datetime import timedelta
import logging
from typing import Dict, List
import aiohttp
import async_timeout
from smhi import Smhi
from smhi.smhi_lib import SmhiForecastException
from homeassistant.components.weather import (
ATTR_FORECAST_CONDITION,
ATTR_FORECAST_PRECIPITATION,
ATTR_FO... |
import asyncio
import logging
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
from ... |
import copy
import errno
import json
DEFAULTS = {
"debug": "false",
"log_file": None,
"log_level": "warning",
"master": "localhost:5050",
"max_workers": 5,
"scheme": "http",
"response_timeout": 5,
}
def load_mesos_config(config_path, profile="default"):
on_disk = {}
try:
... |
try:
import _winreg as winreg
except ImportError:
import winreg
from .windows_tz import win_tz
_cache_tz = None
def valuestodict(key):
"""Convert a registry key's values to a dictionary."""
dict = {}
size = winreg.QueryInfoKey(key)[1]
for i in range(size):
data = winreg.EnumValue(ke... |
import pytest
import voluptuous_serialize
import homeassistant.components.automation as automation
from homeassistant.components.humidifier import DOMAIN, const, device_action
from homeassistant.const import STATE_ON
from homeassistant.helpers import config_validation as cv, device_registry
from homeassistant.setup i... |
from unittest.mock import call, patch
import pytest
import zigpy.profiles.zha as zha
import zigpy.zcl.clusters.general as general
import zigpy.zcl.foundation as zcl_f
from homeassistant.components.switch import DOMAIN
from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE
from .common import (
a... |
from typing import Optional
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.core import callback
from .base import ONVIFBaseEntity
from .const import DOMAIN
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up a ONVIF binary sensor."""
devi... |
import argparse
import glob
import os
import struct
import sys
def clamp_to_min_max(value, min, max):
if value > max:
value = max
elif value < min:
value = min
return value
def clamp_to_u8(value):
return clamp_to_min_max(value, 0, 255)
def parse_args():
parser = argparse.Argum... |
from datetime import timedelta
import json
from airly.exceptions import AirlyError
from homeassistant.components.air_quality import ATTR_AQI, ATTR_PM_2_5, ATTR_PM_10
from homeassistant.components.airly.air_quality import (
ATTRIBUTION,
LABEL_ADVICE,
LABEL_AQI_DESCRIPTION,
LABEL_AQI_LEVEL,
LABEL_P... |
import rumps
import time
def timez():
return time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())
@rumps.timer(1)
def a(sender):
print('%r %r' % (sender, timez()))
@rumps.clicked('Change timer')
def changeit(_):
response = rumps.Window('Enter new interval').run()
if response.clicked:
... |
import os, sys
import os.path as osp
import inspect
from logilab.common import STD_BLACKLIST
from logilab.common.shellutils import globfind
from logilab.common.modutils import load_module_from_file, modpath_from_file
def module_members(module):
members = []
for name, value in inspect.getmembers(module):
... |
from typing import Callable
from pyisy.constants import ISY_VALUE_UNKNOWN
from homeassistant.components.fan import (
DOMAIN as FAN,
SPEED_HIGH,
SPEED_LOW,
SPEED_MEDIUM,
SPEED_OFF,
SUPPORT_SET_SPEED,
FanEntity,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpe... |
from django.apps import apps
from django.conf import settings
from django.db import models
from django.urls import reverse
from zinnia.managers import EntryRelatedPublishedManager
from zinnia.managers import entries_published
def safe_get_user_model():
"""
Safe loading of the User model, customized or not.
... |
import pytest
from queue import Empty
from unittest.mock import Mock
from kombu.transport.consul import Channel, Transport
pytest.importorskip('consul')
class test_Consul:
def setup(self):
self.connection = Mock()
self.connection.client.transport_options = {}
self.connection.client.p... |
import attr
import itertools
import numpy
import scipy.optimize
import sys
def f(*args, simplify=False):
p = ((),)
for l in range(len(args)):
l += 1
p = itertools.chain(p, itertools.product(*(args,), repeat=l))
if simplify:
p = {tuple(sorted(set(x))) for x in p}
p = sorte... |
import os
import re
import subprocess
import diamond.collector
from diamond.collector import str_to_bool
class MountStatsCollector(diamond.collector.Collector):
"""Diamond collector for statistics from /proc/self/mountstats
"""
BYTES_MAP = ['normalreadbytes', 'normalwritebytes', 'directreadbytes',
... |
import logging
from typing import Any, Dict, Optional, cast
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
ATTR_EDITABLE,
ATTR_LATITUDE,
ATTR_LONGITUDE,
CONF_ICON,
CONF_ID,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_NAME,
CONF_RADIUS,
... |
import asyncio
import logging
from homeassistant.components.vacuum import (
ATTR_STATUS,
STATE_CLEANING,
STATE_DOCKED,
STATE_ERROR,
STATE_IDLE,
STATE_PAUSED,
STATE_RETURNING,
SUPPORT_BATTERY,
SUPPORT_LOCATE,
SUPPORT_PAUSE,
SUPPORT_RETURN_HOME,
SUPPORT_SEND_COMMAND,
... |
from functools import partial
from ...utils import verbose
from ..utils import (has_dataset, _data_path, _data_path_doc,
_get_version, _version_doc)
data_name = 'mtrf'
has_mtrf_data = partial(has_dataset, name=data_name)
@verbose
def data_path(path=None, force_update=False, update_path=True, ... |
import configparser
import io
import json.decoder
import os
import shutil
import sys
import time
import requests
import pygments
from pygments.lexers import PythonLexer
from pygments.formatters import TerminalFormatter
from pkg_resources import resource_filename
from nikola.plugin_categories import Command
from niko... |
import os.path as op
import pytest
import numpy as np
from numpy.testing import assert_array_equal, assert_allclose
from scipy.io import savemat
import mne
from mne.datasets import testing
from mne.beamformer import make_lcmv, apply_lcmv, apply_lcmv_cov
from mne.beamformer.tests.test_lcmv import _get_data
from mne.e... |
import json
import arrow
import pem
import requests
import sys
from cryptography import x509
from flask import current_app, g
from lemur.common.utils import validate_conf, convert_pkcs7_bytes_to_pem
from lemur.extensions import metrics
from lemur.plugins import lemur_digicert as digicert
from lemur.plugins.bases impo... |
import time
from six import StringIO
from stash.tests.stashtest import StashTestCase
class ThreadsTests(StashTestCase):
setup_commands = ['BIN_PATH=$STASH_ROOT/tests/system/data:$BIN_PATH']
def test_101(self):
"""
background thread clears properly
"""
self.stash('test_101_... |
from homeassistant.helpers.entity import ToggleEntity
from . import DOMAIN as DAIKIN_DOMAIN
ZONE_ICON = "mdi:home-circle"
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Old way of setting up the platform.
Can only be called when a user accidentally mentions the p... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import posixpath
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import linux_packages
from perfkitbenchmarker import regex_util
from perfkitbenchmarker ... |
from elephas.java import java_classes
from elephas.dl4j import ParameterAveragingModel
from elephas.utils import rdd_utils
import keras
from keras.utils import np_utils
def main():
# Set Java Spark context
conf = java_classes.SparkConf().setMaster('local[*]').setAppName("elephas_dl4j")
jsc = java_classes... |
import chainer
from chainer.backends import cuda
from chainercv import transforms
class YOLOBase(chainer.Chain):
"""Base class for YOLOv2 and YOLOv3.
A subclass of this class should have :obj:`extractor`,
:meth:`forward`, and :meth:`_decode`.
"""
@property
def insize(self):
return ... |
import paramiko
import StringIO
def is_log_success(log):
for x in ['fatal', 'fail', 'error']:
if log.startswith(x) or log.endswith(x):
return False
return True
# ssh to exec cmd
def do_ssh_cmd(ip, port, account, pkey, shell, push_data='', timeout=300):
try:
port = int(port)
... |
from typing import Optional, Sequence
from pysmartthings import Attribute, Capability
from homeassistant.components.lock import LockEntity
from . import SmartThingsEntity
from .const import DATA_BROKERS, DOMAIN
ST_STATE_LOCKED = "locked"
ST_LOCK_ATTR_MAP = {
"codeId": "code_id",
"codeName": "code_name",
... |
from sklearn.pipeline import Pipeline
class ScikitSupervisedCompactor(object):
def __init__(self, pipeline):
'''
Parameters
----------
pipeline : Pipeline
sklearn.pipeline.Pipeline instance
'''
self.pipeline = pipeline
def compact(self, term_doc_matrix, non_text=False):
'''
Parameters
-------... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import flags
from absl.flags import _validators
from absl.testing import absltest
import mock
class NumericFlagBoundsTest(absltest.TestCase):
def setUp(self):
super(NumericFlagBoundsTest, se... |
import configparser
import logging
import os
import click
from twtxt.models import Source
logger = logging.getLogger(__name__)
class Config:
""":class:`Config` interacts with the configuration file.
:param str config_file: full path to the loaded config file
:param ~configparser.ConfigParser cfg: a :... |
import os
from perfkitbenchmarker import linux_packages
URL = 'https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.4.25.tar.gz'
TARBALL = 'linux-4.4.25.tar.gz'
UNTAR_DIR = 'linux-4.4.25'
KERNEL_TARBALL = os.path.join(linux_packages.INSTALL_DIR, TARBALL)
def _Install(vm):
vm.Install('build_tools')
vm.Install('... |
from math import pi
from pygal.adapters import none_to_zero, positive
from pygal.graph.graph import Graph
from pygal.util import alter, decorate
class Pie(Graph):
"""Pie graph class"""
_adapters = [positive, none_to_zero]
def slice(self, serie, start_angle, total):
"""Make a serie slice"""
... |
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 sidekiqweb import SidekiqWebCollector
##########################################################################
class TestSid... |
from datetime import datetime as dt
import pandas as pd
import pytest
import six
from pandas import DataFrame, MultiIndex
from pandas.util.testing import assert_frame_equal
from arctic.chunkstore.date_chunker import DateChunker
from arctic.date import DateRange
def test_date_filter():
c = DateChunker()
df ... |
from io import BytesIO
from urllib.error import HTTPError
from urllib.parse import urlsplit
from xmlrpc.client import ServerProxy
from bs4 import BeautifulSoup
from django.contrib.contenttypes.models import ContentType
from django.contrib.sites.models import Site
from django.test import TestCase
from django.test.uti... |
import logging
import typing
import voluptuous as vol
from homeassistant.const import (
ATTR_EDITABLE,
CONF_ICON,
CONF_ID,
CONF_NAME,
SERVICE_RELOAD,
SERVICE_TOGGLE,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_ON,
)
from homeassistant.core import callback
from homeassistant.helpers i... |
import os
import inspect
from google.auth import credentials
from google.auth.exceptions import RefreshError
from google.api_core.gapic_v1.client_info import ClientInfo
from google.cloud import bigquery
from google.cloud.exceptions import Forbidden
from google.cloud.bigquery._http import Connection
from kaggle_secrets... |
import logging
import yaml
from ansible import context
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.inventory.manager import InventoryManager
from ansible.module_utils.common.collections import ImmutableDict
from ansible.parsing.dataloader import DataLoader
from ansible.playbook.play ... |
import re
from django.utils.translation import gettext_lazy as _
from weblate.checks.format import BaseFormatCheck
RUBY_FORMAT_MATCH = re.compile(
r"""
%( # initial %
(?: # classic printf style
(?:(?P<ord>\d+)\$)? # variab... |
from copy import deepcopy
import pytest
from homeassistant.components import numato
from . import numato_mock
from .common import NUMATO_CFG
@pytest.fixture
def config():
"""Provide a copy of the numato domain's test configuration.
This helps to quickly change certain aspects of the configuration scoped
... |
import vcr
from urllib.request import urlopen
def test_recorded_request_uri_with_redirected_request(tmpdir, httpbin):
with vcr.use_cassette(str(tmpdir.join("test.yml"))) as cass:
assert len(cass) == 0
urlopen(httpbin.url + "/redirect/3")
assert cass.requests[0].uri == httpbin.url + "/redi... |
from __future__ import absolute_import
from __future__ import print_function
import pytest
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.utils import np_utils
from elephas.spark_model import SparkModel
from elephas.utils.rdd_u... |
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
## Order
class MyObject1(event.Componen... |
import abc
import socket
from threading import Thread
import six.moves.cPickle as pickle
from flask import Flask, request
from multiprocessing import Process
from elephas.utils.sockets import determine_master
from elephas.utils.sockets import receive, send
from elephas.utils.serialization import dict_to_model
from el... |
import inspect
import discord
from discord.ext import commands
__all__ = [
"ConversionFailure",
"BotMissingPermissions",
"UserFeedbackCheckFailure",
"ArgParserFailure",
]
class ConversionFailure(commands.BadArgument):
"""Raised when converting an argument fails."""
def __init__(self, conver... |
from ... import event
from . import Widget
class ColorSelectWidget(Widget):
""" A widget used to select a color.
The ``node`` of this widget is an
`<input> <https://developer.mozilla.org/docs/Web/HTML/Element/input>`_
element of type ``color``. This is supported at least
on Firefox and Chrome, b... |
from flexx import app, event, ui
class MyWidget(ui.Label):
""" A Widget that reacts to key presses.
"""
CSS = """
.flx-MyWidget {
min-width: 10px;
min-height: 10px;
padding: 5px;
border: 2px solid black;
border-radius: 5px;
}
"""
def init(self):
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import unittest
from absl.testing import absltest
from absl.testing import xml_reporter
import mock
import six
class MockTestResult(xml_reporter._TextAndXMLTestResult):
def __init__(self):
super(Mock... |
from typing import List
import voluptuous as vol
from homeassistant.components.automation import AutomationActionType
from homeassistant.components.device_automation import TRIGGER_BASE_SCHEMA
from homeassistant.components.homeassistant.triggers import state as state_trigger
from homeassistant.const import (
CON... |
import argparse
import platform
import sys
import os
import numpy
import scipy
import gensim
def package_info():
"""Get the versions of Gensim and its dependencies,
the location where Gensim is installed and platform on which the system is running.
Returns
-------
dict of (str, str)
Dict... |
import re
import inspect
from PyQt5.QtWidgets import QLineEdit, QApplication
import pytest
from qutebrowser.components import readlinecommands
# Some functions aren't 100% readline compatible:
# https://github.com/qutebrowser/qutebrowser/issues/678
# Those are marked with fixme and have another value marked with '... |
import logging
import string
from aiohttp import web
import prometheus_client
import voluptuous as vol
from homeassistant import core as hacore
from homeassistant.components.climate.const import (
ATTR_CURRENT_TEMPERATURE,
ATTR_HVAC_ACTION,
CURRENT_HVAC_ACTIONS,
)
from homeassistant.components.http impor... |
import urllib2
import datetime
try:
import json
except ImportError:
import simplejson as json
import diamond.collector
class DseOpsCenterCollector(diamond.collector.Collector):
last_run_time = 0
column_families = None
last_schema_sync_time = 0
def get_default_config_help(self):
con... |
import numpy as np
from scipy.stats import rankdata, pearsonr
from sklearn.decomposition import PCA, TruncatedSVD
from sklearn.metrics.pairwise import cosine_distances
from scattertext.Scalers import stretch_0_to_1, dense_rank
from scattertext.termcompaction.AssociationCompactor import AssociationCompactor
from scatt... |
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_send
from homeassistant.util import decorator
from .const import CHILD_CALLBACK, MYSENSORS_GATEWAY_READY, NODE_CALLBACK
from .device import get_mysensors_devices
from .helpers import discover_mysensors_platform, vali... |
from importlib import import_module
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.utils.functional import cached_property
def load_class(name, setting):
"""Import module and creates class given by name in string."""
try:
module, attr = name.rspl... |
import json
from coverage import env
from coverage.backward import byte_to_int, bytes_to_ints, binary_bytes, zip_longest
from coverage.misc import contract, new_contract
if env.PY3:
def _to_blob(b):
"""Convert a bytestring into a type SQLite will accept for a blob."""
return b
new_contract('... |
from __future__ import division
import argparse
import multiprocessing
import numpy as np
import chainer
from chainer.training import extensions
from chainer.training.triggers import ManualScheduleTrigger
import chainermn
from chainercv.chainer_experimental.datasets.sliceable \
import TransformDataset
from chai... |
from djangocms_text_ckeditor.models import Text
from djangocms_text_ckeditor.utils import plugin_tags_to_id_list, replace_plugin_tags
from cms.api import add_plugin
from cms.plugin_pool import plugin_pool
from cmsplugin_cascade.models import CascadeElement
def deserialize_to_placeholder(placeholder, data, language):... |
import asyncio
import logging
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_IDLE,
STATE_OFF,
STATE_ON,
STATE_PAUSED,
)
from homeassistant.core import Context, State
from homeassistant.helpers.typi... |
import chainer
from chainer.backends import cuda
import chainer.functions as F
from chainer import reporter
import numpy as np
class PixelwiseSoftmaxClassifier(chainer.Chain):
"""A pixel-wise classifier.
It computes the loss based on a given input/label pair for
semantic segmentation.
Args:
... |
import abc
import logging
import re
from absl import flags
from perfkitbenchmarker import disk
from perfkitbenchmarker import errors
from perfkitbenchmarker import resource
flags.DEFINE_string('smb_tier', 'Standard', 'SMB Mode')
FLAGS = flags.FLAGS
_MOUNT_SMB_RE = re.compile(r'.*type smb \((.*?)\)', re.MULTILINE)
... |
import logging
from pmsensor import serial_pm as pm
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONCENTRATION_MICROGRAMS_PER_CUBIC_METER, CONF_NAME
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import En... |
import logging
from absl import flags
from perfkitbenchmarker import data
from perfkitbenchmarker import errors
from perfkitbenchmarker import linux_packages
from perfkitbenchmarker import vm_util
FLAGS = flags.FLAGS
GIT_REPO = 'https://github.com/aerospike/aerospike-server.git'
GIT_TAG = '4.0.0.1'
AEROSPIKE_DIR = '... |
import collections
import time
import numpy as np
PERCENTILES_LIST = 0.1, 1, 5, 10, 50, 90, 95, 99, 99.9
_SAMPLE_FIELDS = 'metric', 'value', 'unit', 'metadata', 'timestamp'
def PercentileCalculator(numbers, percentiles=PERCENTILES_LIST):
"""Computes percentiles, stddev and mean on a set of numbers.
Args:
n... |
import sys
import cheroot.wsgi
import cheroot.server
import cherrypy
class CPWSGIHTTPRequest(cheroot.server.HTTPRequest):
"""Wrapper for cheroot.server.HTTPRequest.
This is a layer, which preserves URI parsing mode like it which was
before Cheroot v5.8.0.
"""
def __init__(self, server, conn):... |
from tests.async_mock import MagicMock
def _generate_mock_feed_entry(
external_id,
title,
distance_to_home,
coordinates,
attribution=None,
alert_level=None,
country=None,
duration_in_week=None,
event_name=None,
event_type_short=None,
event_type=None,
from_date=None,
... |
from datetime import datetime, timedelta, timezone
import logging
import re
import requests
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_NAME,
CONF_API_KEY,
CONF_ID,
CONF_NAME,
HTTP_OK,
TIME_M... |
import pytest
import voluptuous as vol
from homeassistant.components.humidifier.const import (
ATTR_HUMIDITY,
ATTR_MAX_HUMIDITY,
ATTR_MIN_HUMIDITY,
ATTR_MODE,
DOMAIN,
MODE_AWAY,
MODE_ECO,
SERVICE_SET_HUMIDITY,
SERVICE_SET_MODE,
)
from homeassistant.const import (
ATTR_ENTITY_ID... |
import random
from django.test import SimpleTestCase
from weblate.checks.flags import Flags
from weblate.lang.models import Language, Plural
class MockLanguage(Language):
"""Mock language object."""
class Meta:
proxy = True
def __init__(self, code="cs"):
super().__init__(code=code)
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
_PADDING = 4
slim = tf.contrib.slim
def preprocess_for_train(image,
output_height,
output_width,
padding=_... |
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 interrupt import InterruptCollecto... |
from django.forms import fields, widgets
from django.utils.translation import gettext_lazy as _, ngettext_lazy
from django.utils.text import Truncator
from django.utils.html import format_html
from django.forms.fields import IntegerField
from django.template.loader import select_template
from entangled.forms import En... |
import re
import numpy as np
import pytest
import xarray as xr
from . import assert_equal, requires_dask
@pytest.fixture(params=[np.str_, np.bytes_])
def dtype(request):
return request.param
@requires_dask
def test_dask():
import dask.array as da
arr = da.from_array(["a", "b", "c"], chunks=-1)
... |
import os
from pylatex import Document, PageStyle, Head, Foot, MiniPage, \
StandAloneGraphic, MultiColumn, Tabu, LongTabu, LargeText, MediumText, \
LineBreak, NewPage, Tabularx, TextColor, simple_page_number
from pylatex.utils import bold, NoEscape
def generate_unique():
geometry_options = {
"he... |
import os
import re
import diamond.collector
class NagiosPerfdataCollector(diamond.collector.Collector):
"""Diamond collector for Nagios performance data
"""
GENERIC_FIELDS = ['DATATYPE', 'HOSTNAME', 'TIMET']
HOST_FIELDS = ['HOSTPERFDATA']
SERVICE_FIELDS = ['SERVICEDESC', 'SERVICEPERFDATA']
... |
from __future__ import print_function
import os
import sys
from functools import wraps
from six.moves import input
_stash = globals()["_stash"]
try:
import github
except ImportError:
print("Could not import 'github', installing it...")
_stash("pip install pygithub")
import github
try:
import doc... |
from defusedxml import ElementTree
import pytest
from homeassistant.const import HTTP_NOT_FOUND
from homeassistant.setup import async_setup_component
@pytest.fixture
def mock_http_client(loop, hass, hass_client):
"""Set up test fixture."""
config = {
"rss_feed_template": {
"testfeed": {
... |
import sys
__all__ = ['PY3', 'b', 'basestring_', 'bytes', 'next', 'is_unicode']
PY3 = True if sys.version_info[0] == 3 else False
if sys.version_info[0] < 3:
b = bytes = str
basestring_ = basestring
else:
def b(s):
if isinstance(s, str):
return s.encode('latin1')
return byte... |
from typing import Set
from weblate.machinery.base import BatchStringMachineTranslation, get_machinery_language
from weblate.memory.models import Memory
class WeblateMemory(BatchStringMachineTranslation):
"""Translation service using strings already translated in Weblate."""
name = "Weblate Translation Mem... |
import unittest
import six
from trashcli.restore import TrashDirectory
from integration_tests.files import require_empty_dir
from integration_tests.files import make_file
from mock import Mock
class TestTrashDirectory(unittest.TestCase):
def setUp(self):
require_empty_dir('sandbox')
self.trash... |
import os
import numpy as np
import pandas as pd
import xarray as xr
from . import randint, randn, requires_dask
try:
import dask
import dask.multiprocessing
except ImportError:
pass
os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE"
class IOSingleNetCDF:
"""
A few examples that benchmark readin... |
GIT_PATH = 'https://github.com/google/multichase'
GIT_VERSION = 'ebd614435f9d510963c5568d840ff647ca8e3701'
INSTALL_PATH = 'multichase'
def _Install(vm):
"""Installs the multichase package on the VM."""
vm.Install('build_tools')
vm.RemoteCommand('rm -rf {path} && mkdir -p {path}'.format(
path=INSTALL_PATH... |
from pylatex import Document, MiniPage, LineBreak, VerticalSpace
def generate_labels():
geometry_options = {"margin": "0.5in"}
doc = Document(geometry_options=geometry_options)
doc.change_document_style("empty")
for i in range(10):
with doc.create(MiniPage(width=r"0.5\textwidth")):
... |
import collections
import re
import time
from absl import flags
import numpy as np
from perfkitbenchmarker import configs
from perfkitbenchmarker import regex_util
from perfkitbenchmarker import sample
from perfkitbenchmarker import vm_util
flags.DEFINE_integer('nccl_slots', 8,
'Launch n processe... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.