text stringlengths 213 32.3k |
|---|
from django.contrib.sitemaps import Sitemap
from django.urls import reverse
from weblate.trans.models import Change, Component, Project, Translation
from weblate.utils.stats import prefetch_stats
class PagesSitemap(Sitemap):
def items(self):
return (
("/", 1.0, "daily"),
("/about... |
from typing import Dict, Sequence, Union
from gi.repository import Gtk
VIEW_ACCELERATORS: Dict[str, Union[str, Sequence[str]]] = {
'app.quit': '<Primary>Q',
'view.find': '<Primary>F',
'view.find-next': '<Primary>G',
'view.find-previous': '<Primary><Shift>G',
'view.find-replace': '<Primary>H',
... |
class Neuron(object):
"""
This Class is representing a Neuron which is corresponding to an action to perform.
.. note:: Neurons are defined in the brain file
"""
def __init__(self, name=None, parameters=dict()):
self.name = name
self.parameters = parameters
def serialize(self... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import sys
from pyspark.sql import SparkSession
def main():
spark = (SparkSession.builder
.appName('Setup Spark table')
.enableHiveSupport()
.getOrCreate())
table = 'ware... |
from weblate.auth.models import create_groups, setup_project_groups
from weblate.trans.models import Project
from weblate.utils.management.base import BaseCommand
class Command(BaseCommand):
help = "setups default user groups"
def add_arguments(self, parser):
parser.add_argument(
"--no-p... |
from typing import Callable
from homeassistant.components.cover import (
DEVICE_CLASS_SHUTTER,
DEVICE_CLASSES,
CoverEntity,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant, callback
from .dynalitebase import DynaliteBase, async_setup_entry_base
DEFAULT... |
from functools import wraps
import logging
from typing import Any, Awaitable, Callable
from aiohttp import web
import voluptuous as vol
from homeassistant.const import HTTP_BAD_REQUEST
from .view import HomeAssistantView
_LOGGER = logging.getLogger(__name__)
class RequestDataValidator:
"""Decorator that will... |
from datetime import timedelta
import logging
import time
import requests
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_ATTRIBUTION,
CONF_API_KEY,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_NAME,
)
import homeassistant.helpers... |
import argparse
import json
from django.core.serializers.json import DjangoJSONEncoder
from weblate.accounts.models import Profile
from weblate.utils.management.base import BaseCommand
class Command(BaseCommand):
help = "dumps user data to JSON file"
def add_arguments(self, parser):
parser.add_arg... |
import logging
import pytest
from qutebrowser.config import configdata
from qutebrowser.utils import usertypes, version
from qutebrowser.browser.webengine import darkmode
from qutebrowser.misc import objects
from helpers import utils
@pytest.fixture(autouse=True)
def patch_backend(monkeypatch):
monkeypatch.set... |
import csv
from django.http import HttpResponse, JsonResponse
from weblate.api.serializers import StatisticsSerializer
from weblate.trans.stats import get_project_stats
from weblate.utils.views import get_component, get_project
def export_stats_project(request, project):
"""Export stats in JSON format."""
... |
from homeassistant.components.notify import BaseNotificationService
EVENT_NOTIFY = "notify"
def get_service(hass, config, discovery_info=None):
"""Get the demo notification service."""
return DemoNotificationService(hass)
class DemoNotificationService(BaseNotificationService):
"""Implement demo notifi... |
import logging
from serial import SerialException
from homeassistant import core
from homeassistant.components.media_player import MediaPlayerEntity
from homeassistant.components.media_player.const import (
SUPPORT_SELECT_SOURCE,
SUPPORT_TURN_OFF,
SUPPORT_TURN_ON,
SUPPORT_VOLUME_MUTE,
SUPPORT_VOL... |
from homeassistant.const import CONF_NAME
from . import PiHoleEntity
from .const import (
ATTR_BLOCKED_DOMAINS,
DATA_KEY_API,
DATA_KEY_COORDINATOR,
DOMAIN as PIHOLE_DOMAIN,
SENSOR_DICT,
SENSOR_LIST,
)
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up the Pi-hole sen... |
import logging
import pytest
from homeassistant.components.yessssms.const import CONF_PROVIDER
import homeassistant.components.yessssms.notify as yessssms
from homeassistant.const import (
CONF_PASSWORD,
CONF_RECIPIENT,
CONF_USERNAME,
HTTP_INTERNAL_SERVER_ERROR,
)
from homeassistant.setup import asyn... |
import base64
from kombu.message import Message
from kombu.utils.encoding import str_to_bytes
class BaseAsyncMessage(Message):
"""Base class for messages received on async client."""
class AsyncRawMessage(BaseAsyncMessage):
"""Raw Message."""
class AsyncMessage(BaseAsyncMessage):
"""Serialized messa... |
from django.urls import reverse
from weblate.trans.tests.test_views import FixtureTestCase
class BasicViewTest(FixtureTestCase):
def test_about(self):
response = self.client.get(reverse("about"))
self.assertContains(response, "translate-toolkit")
def test_keys(self):
response = self... |
import logging
import pyatmo
import requests
import voluptuous as vol
from homeassistant.components.camera import SUPPORT_STREAM, Camera
from homeassistant.core import callback
from homeassistant.helpers import config_validation as cv, entity_platform
from homeassistant.helpers.dispatcher import async_dispatcher_con... |
import numpy as np
from hypertools.tools import text2mat
from sklearn.decomposition import LatentDirichletAllocation
data = [['i like cats alot', 'cats r pretty cool', 'cats are better than dogs'],
['dogs rule the haus', 'dogs are my jam', 'dogs are a mans best friend']]
def test_transform_text():
assert... |
from mock import patch, Mock, call, MagicMock
from arctic.scripts.utils import do_db_auth
def test_do_db_auth():
# Create the user agains the current mongo database
admin_creds = Mock()
user_creds = Mock()
connection = MagicMock()
with patch('arctic.scripts.utils.logger', autospec=True) as logge... |
import typing
import keras
from keras.models import Model
from matchzoo.engine.base_model import BaseModel
from matchzoo.engine.param import Param
from matchzoo.engine.param_table import ParamTable
from matchzoo import preprocessors
from matchzoo.utils import TensorType
class CDSSM(BaseModel):
"""
CDSSM Mo... |
from stash.tests.stashtest import StashTestCase
class LibDistTests(StashTestCase):
"""
Tests for 'libdist'
"""
def test_libdist_is_loaded(self):
"""
Test that 'libdist' is loaded.
"""
loaded_libs = [an for an in dir(self.stash) if an.startswith("lib")]
self.ass... |
import datetime
from homeassistant.components.manual.alarm_control_panel import ManualAlarm
from homeassistant.const import (
CONF_ARMING_TIME,
CONF_DELAY_TIME,
CONF_TRIGGER_TIME,
STATE_ALARM_ARMED_AWAY,
STATE_ALARM_ARMED_CUSTOM_BYPASS,
STATE_ALARM_ARMED_HOME,
STATE_ALARM_ARMED_NIGHT,
... |
import asyncio
from functools import wraps
from typing import Awaitable, Callable
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import Unauthorized
from . import const, messages
from .connection import ActiveConnection
# mypy: allow-untyped-calls, allow-untyped-defs
async de... |
from binascii import hexlify
import logging
import voluptuous as vol
from xbee_helper.exceptions import ZigBeeException, ZigBeeTxFailure
from homeassistant.const import TEMP_CELSIUS
from homeassistant.helpers.entity import Entity
from . import DOMAIN, PLATFORM_SCHEMA, XBeeAnalogIn, XBeeAnalogInConfig, XBeeConfig
_... |
from pylatex.base_classes import Environment
from pylatex.package import Package
from pylatex import Document, Section
from pylatex.utils import NoEscape
class AllTT(Environment):
"""A class to wrap LaTeX's alltt environment."""
packages = [Package('alltt')]
escape = False
content_separator = "\n"
... |
import json
from homeassistant.components.gios.const import DOMAIN
from tests.async_mock import patch
from tests.common import MockConfigEntry, load_fixture
STATIONS = [
{"id": 123, "stationName": "Test Name 1", "gegrLat": "99.99", "gegrLon": "88.88"},
{"id": 321, "stationName": "Test Name 2", "gegrLat": "7... |
from homeassistant.components.atag import CLIMATE, DOMAIN
from homeassistant.components.climate import (
ATTR_HVAC_ACTION,
ATTR_HVAC_MODE,
ATTR_PRESET_MODE,
HVAC_MODE_HEAT,
SERVICE_SET_HVAC_MODE,
SERVICE_SET_PRESET_MODE,
SERVICE_SET_TEMPERATURE,
)
from homeassistant.components.climate.const... |
import json
from aiohttp.hdrs import AUTHORIZATION
import homeassistant.components.html5.notify as html5
from homeassistant.const import HTTP_INTERNAL_SERVER_ERROR
from homeassistant.exceptions import HomeAssistantError
from homeassistant.setup import async_setup_component
from tests.async_mock import MagicMock, mo... |
import pytest
from unittest.mock import Mock, patch
from kombu import Connection, Exchange, Queue
from kombu import compat
from t.mocks import Transport, Channel
class test_misc:
def test_iterconsume(self):
class MyConnection:
drained = 0
def drain_events(self, *args, **kwar... |
parameters = {
'KMeans': {'n_clusters': 5},
'MiniBatchKMeans': {'n_clusters': 5},
'SpectralClustering': {'n_clusters': 5,
'affinity': 'nearest_neighbors',
'n_neighbors': 10},
'AgglomerativeClustering': {'n_clusters': 5, 'linkage' : 'ward'},
'Fea... |
import asyncio
from pyflick.authentication import AuthException
from homeassistant import config_entries, data_entry_flow, setup
from homeassistant.components.flick_electric.const import DOMAIN
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from tests.async_mock import patch
from tests.common import M... |
import unittest.mock
import pytest
from PyQt5.QtCore import QObject
from PyQt5.QtGui import QStandardItemModel
from qutebrowser.completion import completer
from qutebrowser.commands import command
from qutebrowser.api import cmdutils
@pytest.fixture(autouse=True)
def setup_cur_tab(tabbed_browser_stubs, fake_web_ta... |
from typing import TYPE_CHECKING, Generic, Hashable, Mapping, Optional, TypeVar
import numpy as np
from .options import _get_keep_attrs
from .pdcompat import count_not_none
from .pycompat import is_duck_dask_array
if TYPE_CHECKING:
from .dataarray import DataArray # noqa: F401
from .dataset import Dataset ... |
import builtins
import json
import unittest
from absl import flags as flgs
import contextlib2
import mock
from perfkitbenchmarker import os_types
from perfkitbenchmarker import providers
from perfkitbenchmarker import virtual_machine
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers.azure import... |
import json
from appconf import AppConf
from django.core.exceptions import ObjectDoesNotExist
from django.db import models
from django.db.models import Q
from django.db.models.signals import post_delete, post_save
from django.dispatch import receiver
from django.utils.functional import cached_property
from weblate.u... |
revision = "ee827d1e1974"
down_revision = "7ead443ba911"
from alembic import op
from sqlalchemy.exc import ProgrammingError
def upgrade():
connection = op.get_bind()
connection.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm")
op.create_index(
"ix_certificates_cn",
"certificates",
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import multiprocessing
import multiprocessing.managers
import os
import signal
import threading
import unittest
from perfkitbenchmarker import background_tasks
from perfkitbenchmarker import ... |
from abc import ABCMeta, abstractmethod
class ExecutionAlgorithm(object):
"""
Callable which takes in a list of desired rebalance Orders
and outputs a new Order list with a particular execution
algorithm strategy.
"""
__metaclass__ = ABCMeta
@abstractmethod
def __call__(self, dt, in... |
import pandas as pd
import time
import itertools as itt
from queue import Empty
from threading import Lock
import threading as th
import logging
logger = logging.getLogger(__name__)
def records_to_df(records):
records = pd.DataFrame.from_records(records)
records['receive_ts'] = records['send_ts'] + records['... |
from uuid import uuid4
from builtins import int
__test_missile = """\
POST /example/search/hello/help/us?param1=50¶m2=0¶m3=hello HTTP/1.1\r
Connection: close\r
Host: example.org\r
Content-length: 32\r
\r
param1=50¶m2=0¶m3=hello
"""
def __mark_by_uri(missile):
return '_'.join(
missile.dec... |
from collections import defaultdict
from functools import reduce
import logging
import multiprocessing
from pycec.cec import CecAdapter # pylint: disable=import-error
from pycec.commands import ( # pylint: disable=import-error
CecCommand,
KeyPressCommand,
KeyReleaseCommand,
)
from pycec.const import ( ... |
import os
from itertools import chain
from .connection import Resource
from .messaging import Producer
from .utils.collections import EqualityDict
from .utils.compat import register_after_fork
from .utils.functional import lazy
__all__ = ('ProducerPool', 'PoolGroup', 'register_group',
'connections', 'pro... |
import datetime
import re
import time
def current_time():
"""Return the current datetime."""
return datetime.datetime.now()
def current_timestamp():
"""Return the current time as a timestamp."""
return to_timestamp(current_time())
def to_timestamp(time_val):
"""Generate a unix timestamp for t... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import abc
import logging
from absl import flags
from perfkitbenchmarker import resource
from perfkitbenchmarker.configs import option_decoders
from perfkitbenchmarker.configs import spec
import six
flags.DE... |
from pytest import mark
from cerberus.tests import assert_fail, assert_success
@mark.parametrize(
("test_function", "document"),
[(assert_success, {'user': 'alice'}), (assert_fail, {'user': 'admin'})],
)
def test_forbidden(test_function, document):
test_function(schema={'user': {'forbidden': ['root', 'a... |
import os
import time
import json
import getpass
import binascii
import hashlib
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, Qt
from PyQt5.QtNetwork import QLocalSocket, QLocalServer, QAbstractSocket
import qutebrowser
from qutebrowser.utils import log, usertypes, error, standarddir, utils
from qutebrowse... |
from __future__ import print_function
import pytest
from plumbum import local
from plumbum.cli import Config, ConfigINI
fname = 'test_config.ini'
@pytest.mark.usefixtures('cleandir')
class TestConfig:
def test_makefile(self):
with ConfigINI(fname) as conf:
conf['value'] = 12
c... |
import re # noqa: F401
import sys # noqa: F401
import nulltype # noqa: F401
from paasta_tools.paastaapi.model_utils import ( # noqa: F401
ApiTypeError,
ModelComposed,
ModelNormal,
ModelSimple,
cached_property,
change_keys_js_to_python,
convert_js_args_to_python_args,
date,
dat... |
from tests.common import assert_lists_same, async_get_device_automations
from tests.components.homekit_controller.common import (
Helper,
setup_accessories_from_file,
setup_test_accessories,
)
async def test_hue_bridge_setup(hass):
"""Test that a Hue hub can be correctly setup in HA via HomeKit."""
... |
import logging
from kalliope import Utils
from kalliope.signals.order import Order
logging.basicConfig()
logger = logging.getLogger("kalliope")
class SignalLauncher:
# keep a list of instantiated signals
list_launched_signals = list()
def __init__(self):
pass
@classmethod
def launch_... |
import logging
import requests
import voluptuous as vol
from homeassistant.components.http import HomeAssistantView
from homeassistant.const import (
CONF_ACCESS_TOKEN,
HTTP_BAD_REQUEST,
HTTP_CREATED,
HTTP_OK,
)
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name_... |
from copy import copy
import socket
import unittest
from uuid import uuid4
import homeassistant.components.tcp.sensor as tcp
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.template import Template
from homeassistant.setup import setup_component
from tests.async_mock import Mock, patch
fro... |
from typing import Any
from xknx.devices import Scene as XknxScene
from homeassistant.components.scene import Scene
from .const import DOMAIN
from .knx_entity import KnxEntity
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the scenes for KNX platform."""
e... |
from unittest.mock import PropertyMock, patch
import homeassistant.components.image_processing as ip
import homeassistant.components.microsoft_face as mf
from homeassistant.const import ATTR_ENTITY_PICTURE, STATE_UNKNOWN
from homeassistant.core import callback
from homeassistant.setup import setup_component
from tes... |
from collections import OrderedDict
from django.contrib import admin
from django.contrib.auth import get_user_model
from django.forms import fields, models, widgets
from django.utils.translation import gettext_lazy as _
from django_fsm import RETURN_VALUE
from shop.models.notification import Notify, Notification, N... |
import os
def test_that_tests_dont_have_multiple_functions_with_same_name():
dir = os.path.dirname(__file__)
for fname in os.listdir(dir):
if not (fname.startswith('test_') and fname.endswith('.py')):
continue
print(fname)
text = open(os.path.join(dir, fname), 'rb').read().... |
import os.path as op
import numpy as np
from scipy.signal import welch, coherence, unit_impulse
from matplotlib import pyplot as plt
import mne
from mne.simulation import simulate_raw, add_noise
from mne.datasets import sample
from mne.minimum_norm import make_inverse_operator, apply_inverse
from mne.time_frequency i... |
from decouple import Csv
def test_csv():
csv = Csv()
assert ['127.0.0.1', '.localhost', '.herokuapp.com'] == \
csv('127.0.0.1, .localhost, .herokuapp.com')
csv = Csv(int)
assert [1, 2, 3, 4, 5] == csv('1,2,3,4,5')
csv = Csv(post_process=tuple)
assert ('HTTP_X_FORWARDED_PROTO', 'http... |
from datetime import timedelta, datetime as dt
from time import strptime
import pytz
from pytz import utc
from dateutil.tz import gettz, tzoffset
DATE_FORMAT = '%m/%d/%Y'
DATETIME_FORMAT = '{0} %H:%M:%S'.format(DATE_FORMAT)
TIMEOUT = 60 * 60 * 1
HALF_DAY = 60 * 60 * 12
TODAY = dt.utcnow()
def gen_tzinfos():
f... |
import os
import time
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from test import run_only
from mock import patch
from diamond.collector import Collector
from processresources import ProcessResourcesCollector
####################################################... |
import difflib
import os
from gi.repository import Gdk, Gio, GLib, Gtk, GtkSource
from meld.conf import _
from meld.iohelpers import prompt_save_filename
from meld.misc import error_dialog
from meld.settings import get_meld_settings
from meld.sourceview import LanguageManager
@Gtk.Template(resource_path='/org/gnom... |
from homeassistant import config_entries
from homeassistant.components.ozw import DOMAIN, PLATFORMS, const
from .common import setup_ozw
from tests.common import MockConfigEntry
async def test_init_entry(hass, generic_data):
"""Test setting up config entry."""
await setup_ozw(hass, fixture=generic_data)
... |
import collections
class LRUDict:
"""
dict with LRU-eviction and max-size
This is intended for caching, it may not behave how you want otherwise
This uses collections.OrderedDict under the hood, but does not directly expose
all of it's methods (intentional)
"""
def __init__(self, *keyv... |
from typing import List
import voluptuous as vol
from homeassistant.components.automation import AutomationActionType
from homeassistant.components.device_automation import toggle_entity
from homeassistant.const import CONF_DOMAIN
from homeassistant.core import CALLBACK_TYPE, HomeAssistant
from homeassistant.helpers... |
import logging
import unittest
import numpy as np
from scipy import sparse
from scipy.special import psi # gamma function utils
import gensim.matutils as matutils
# we'll define known, good (slow) version of functions here
# and compare results from these functions vs. cython ones
def logsumexp(x):
"""Log of s... |
from __future__ import division, print_function
from urwid.util import calc_width, calc_text_pos, calc_trim_text, is_wide_char, \
move_prev_char, move_next_char
from urwid.compat import bytes, PYTHON3, B, xrange
class TextLayout:
def supports_align_mode(self, align):
"""Return True if align is a supp... |
from django.conf.urls import url, include
from django.http import JsonResponse
from rest_framework import routers
from shop.forms.checkout import ShippingAddressForm, BillingAddressForm
from shop.messages import get_messages_as_json
from shop.views.address import AddressEditView
from shop.views.cart import CartViewSe... |
import sys
import urwid
class LineWalker(urwid.ListWalker):
"""ListWalker-compatible class for lazily reading file contents."""
def __init__(self, name):
self.file = open(name)
self.lines = []
self.focus = 0
def get_focus(self):
return self._get_at_pos(self.focus)
... |
import voluptuous as vol
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import CONF_NAME
import homeassistant.helpers.config_validation as cv
from . import DOMAIN, KEY_STATUS, VALUE_ONLINE
DEFAULT_NAME = "UPS Online Status"
PLATFORM_SCHEMA = PLATFORM_... |
from typing import Dict, Optional
import uuid
from homeassistant.core import HomeAssistant
from . import singleton, storage
DATA_KEY = "core.uuid"
DATA_VERSION = 1
LEGACY_UUID_FILE = ".uuid"
@singleton.singleton(DATA_KEY)
async def async_get(hass: HomeAssistant) -> str:
"""Get unique ID for the hass instance... |
import os
from django.test import SimpleTestCase
from weblate.utils.environment import (
get_env_bool,
get_env_int,
get_env_list,
get_env_map,
modify_env_list,
)
class EnvTest(SimpleTestCase):
def test_list(self):
os.environ["TEST_DATA"] = "foo,bar,baz"
self.assertEqual(get_... |
from datetime import datetime, timedelta
import secrets
from typing import Dict, List, NamedTuple, Optional
import uuid
import attr
from homeassistant.util import dt as dt_util
from . import permissions as perm_mdl
from .const import GROUP_ID_ADMIN
TOKEN_TYPE_NORMAL = "normal"
TOKEN_TYPE_SYSTEM = "system"
TOKEN_TY... |
from datetime import timedelta
import logging
import magicseaweed
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_ATTRIBUTION,
CONF_API_KEY,
CONF_MONITORED_CONDITIONS,
CONF_NAME,
)
import homeassistant.helpers.config_validati... |
import json
from unittest.mock import patch, Mock
import arrow
import pytest
from cryptography import x509
from freezegun import freeze_time
from lemur.plugins.lemur_digicert import plugin
from lemur.tests.vectors import CSR_STR
def config_mock(*args):
values = {
"DIGICERT_ORG_ID": 111111,
"DIGI... |
from docutils.nodes import reference
from docutils.parsers.rst.roles import set_classes
# adapted from
# https://doughellmann.com/blog/2010/05/09/defining-custom-roles-in-sphinx/
def gh_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
"""Link to a GitHub issue."""
try:
# issue/PR... |
import collections
import errno
import functools
import os
import shutil
import subprocess
from pathlib import PurePath
from typing import (
TYPE_CHECKING,
AnyStr,
Callable,
Generator,
List,
Optional,
Pattern,
Sequence,
Tuple,
Union,
)
from gi.repository import GLib, Gtk
from ... |
import logging
import pytest
import pytest_bdd as bdd
bdd.scenarios('open.feature')
@pytest.mark.parametrize('scheme', ['http://', ''])
def test_open_s(request, quteproc, ssl_server, scheme):
"""Test :open with -s."""
quteproc.set_setting('content.ssl_strict', 'false')
quteproc.send_cmd(':open -s {}loca... |
import unittest
from unittest import mock
import pytest
import requests.exceptions
import somecomfort
import voluptuous as vol
from homeassistant.components.climate.const import (
ATTR_FAN_MODE,
ATTR_FAN_MODES,
ATTR_HVAC_MODES,
)
import homeassistant.components.honeywell.climate as honeywell
from homeass... |
import diamond.collector
import datetime
from diamond.collector import str_to_bool
import re
import zlib
try:
import pymongo
except ImportError:
pymongo = None
try:
from pymongo import ReadPreference
except ImportError:
ReadPreference = None
class MongoDBCollector(diamond.collector.Collector):
... |
import sys
import json
import qutebrowser
try:
from qutebrowser.misc.checkpyver import check_python_version
except ImportError:
try:
# python2
from .misc.checkpyver import check_python_version
except (SystemError, ValueError):
# Import without module - SystemError on Python3, Value... |
import logging
from homeassistant.components.media_player import MediaPlayerEntity
from homeassistant.components.media_player.const import (
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_MUSIC,
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PLAY_MEDIA,
SUPPORT_PREVIOUS_TRACK,
SUPPORT_SELECT... |
import asyncio
import logging
from typing import Any, Dict
from aiohttp import ClientResponseError
from homeassistant.components.water_heater import (
DOMAIN as WATER_HEATER_DOMAIN,
WaterHeaterEntity,
)
from homeassistant.const import TEMP_CELSIUS
from homeassistant.helpers.dispatcher import async_dispatcher... |
import logging
from pyhomeworks.pyhomeworks import HW_BUTTON_PRESSED, HW_BUTTON_RELEASED, Homeworks
import voluptuous as vol
from homeassistant.const import (
CONF_HOST,
CONF_ID,
CONF_NAME,
CONF_PORT,
EVENT_HOMEASSISTANT_STOP,
)
from homeassistant.core import callback
import homeassistant.helpers... |
import contextlib
import io
import threading
import warnings
from typing import Any, Dict, cast
from ..core import utils
from ..core.options import OPTIONS
from .locks import acquire
from .lru_cache import LRUCache
# Global cache for storing open files.
FILE_CACHE: LRUCache[str, io.IOBase] = LRUCache(
maxsize=ca... |
from __future__ import unicode_literals
import os
import time
import string
from lib.fun.fun import cool
from collections import Counter
from lib.fun.decorator import magic
from lib.data.data import pystrs, pyoptions
def counter_operator(original_file_path, justsave, justview, vs_count=pyoptions.default_vs_items):
... |
import pkgutil
from io import StringIO
import pandas as pd
from scipy.stats import rankdata
class BackgroundFrequencyDataFramePreparer(object):
@staticmethod
def prep_background_frequency(df):
df['rank'] = rankdata(df.background, method='dense')
df['background'] = df['rank'] / df['rank'].max... |
from __future__ import print_function
import argparse, os, sys
def rmdir(dirnames, verbose=False):
for dirname in dirnames:
try:
os.rmdir(dirname)
if verbose:
print('Removed directory {!r}'.format(dirname))
except OSError as e:
print('Cannot re... |
from collections import OrderedDict
import logging
import queue
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_PAYLOAD,
CONF_PORT,
CONF_PROTOCOL,
CONF_USERNAME,
)
from .const import (
ATTR_PAYLOAD,
AT... |
import os
import html
import netrc
from typing import Callable, Mapping
from PyQt5.QtCore import QUrl
from qutebrowser.config import config
from qutebrowser.utils import usertypes, message, log, objreg, jinja, utils
from qutebrowser.mainwindow import mainwindow
class CallSuper(Exception):
"""Raised when the ca... |
import mock
from paasta_tools.cli.cmds.pause_service_autoscaler import MAX_PAUSE_DURATION
from paasta_tools.cli.cmds.pause_service_autoscaler import (
paasta_pause_service_autoscaler,
)
@mock.patch("paasta_tools.cli.cmds.pause_service_autoscaler._log_audit", autospec=True)
def test_pause_autoscaler_defaults(moc... |
from _csv import QUOTE_NONE
import pandas as pd
import numpy as np
import logging
import json
import time
import datetime
import itertools as itt
from pandas.errors import ParserError
from yandextank.common.interfaces import StatsReader
from io import StringIO
logger = logging.getLogger(__name__)
phout_columns =... |
class CallFailure(Exception):
"""Exception raised when a Google Music server responds that a call failed.
Attributes:
callname -- name of the protocol.Call that failed
"""
def __init__(self, message, callname):
Exception.__init__(self, message)
self.callname = callname
de... |
import logging
from saltbox import RouterLoginException, RouterNotReachableException, SaltBox
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
import homeassista... |
import asyncio
from datetime import timedelta
from itertools import chain
import logging
from haffmpeg.camera import CameraMjpeg
from haffmpeg.tools import IMAGE_JPEG, ImageFrame
import requests
from homeassistant.components.camera import Camera
from homeassistant.components.ffmpeg import DATA_FFMPEG
from homeassist... |
from hangups import CredentialsPrompt, GoogleAuthError, RefreshTokenCache
class Google2FAError(GoogleAuthError):
"""A Google authentication request failed."""
class HangoutsCredentials(CredentialsPrompt):
"""Google account credentials.
This implementation gets the user data as params.
"""
def... |
import unittest
from bayes_opt import BayesianOptimization
class TestBayesOpt(unittest.TestCase):
def test_optimize(self):
# Bounded region of parameter space
pbounds = {'x': (2, 4), 'y': (-3, 3)}
optimizer = BayesianOptimization(
f=black_box_function,
pbounds=pb... |
import blebox_uniapi
import pytest
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.blebox import config_flow
from homeassistant.setup import async_setup_component
from .conftest import mock_config, mock_only_feature, setup_product_mock
from tests.async_mock import DEFAULT, As... |
import logging
import os
import os.path
import re
import xml.sax # for parsing arxmliv articles
from gensim import utils
import sys
if sys.version_info[0] >= 3:
unicode = str
PAT_TAG = re.compile(r'<(.*?)>(.*)</.*?>')
logger = logging.getLogger('gensim.corpora.sources')
class ArticleSource:
"""
Obje... |
from mock import patch, call, ANY
from arctic.scripts.arctic_create_user import main
from ...util import run_as_main
def test_main_minimal():
with patch('arctic.scripts.arctic_create_user.logger', autospec=True) as logger, \
patch('arctic.scripts.arctic_create_user.MongoClient', autospec=True) as MC, \... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.