Search is not available for this dataset
text stringlengths 75 104k |
|---|
def init_logging(log_level):
"""
Initialise the logging by adding an observer to the global log publisher.
:param str log_level: The minimum log level to log messages for.
"""
log_level_filter = LogLevelFilterPredicate(
LogLevel.levelWithName(log_level))
log_level_filter.setLogLevelForN... |
def _parse_field_value(line):
""" Parse the field and value from a line. """
if line.startswith(':'):
# Ignore the line
return None, None
if ':' not in line:
# Treat the entire line as the field, use empty string as value
return line, ''
# Else field is before the ':' a... |
def _abortConnection(self):
"""
We need a way to close the connection when an event line is too long
or if we time out waiting for an event. This is normally done by
calling :meth:`~twisted.internet.interfaces.ITransport.loseConnection``
or :meth:`~twisted.internet.interfaces.ITC... |
def dataReceived(self, data):
"""
Translates bytes into lines, and calls lineReceived.
Copied from ``twisted.protocols.basic.LineOnlyReceiver`` but using
str.splitlines() to split on ``\r\n``, ``\n``, and ``\r``.
"""
self.resetTimeout()
lines = (self._buffer + da... |
def _handle_field_value(self, field, value):
""" Handle the field, value pair. """
if field == 'event':
self._event = value
elif field == 'data':
self._data_lines.append(value)
elif field == 'id':
# Not implemented
pass
elif field =... |
def _dispatch_event(self):
"""
Dispatch the event to the handler.
"""
data = self._prepare_data()
if data is not None:
self._handler(self._event, data)
self._reset_event_data() |
def listen_events(self, reconnects=0):
"""
Start listening for events from Marathon, running a sync when we first
successfully subscribe and triggering a sync on API request events.
"""
self.log.info('Listening for events from Marathon...')
self._attached = False
... |
def sync(self):
"""
Fetch the list of apps from Marathon, find the domains that require
certificates, and issue certificates for any domains that don't already
have a certificate.
"""
self.log.info('Starting a sync...')
def log_success(result):
self.l... |
def _issue_cert(self, domain):
"""
Issue a certificate for the given domain.
"""
def errback(failure):
# Don't fail on some of the errors we could get from the ACME
# server, rather just log an error so that we can continue with
# other domains.
... |
def warn_if_detached(func):
""" Warn if self / cls is detached. """
@wraps(func)
def wrapped(this, *args, **kwargs):
# Check for _detached in __dict__ instead of using hasattr
# to avoid infinite loop in __getattr__
if '_detached' in this.__dict__ and this._detached:
warn... |
def has_storage(func):
""" Ensure that self/cls contains a Storage backend. """
@wraps(func)
def wrapped(*args, **kwargs):
me = args[0]
if not hasattr(me, '_storage') or \
not me._storage:
raise exceptions.ImproperConfigurationError(
'No storage ba... |
def rm_fwd_refs(obj):
"""When removing an object, other objects with references to the current
object should remove those references. This function identifies objects
with forward references to the current object, then removes those
references.
:param obj: Object to which forward references should ... |
def rm_back_refs(obj):
"""When removing an object with foreign fields, back-references from
other objects to the current object should be deleted. This function
identifies foreign fields of the specified object whose values are not
None and which specify back-reference keys, then removes back-references... |
def ensure_backrefs(obj, fields=None):
"""Ensure that all forward references on the provided object have the
appropriate backreferences.
:param StoredObject obj: Database record
:param list fields: Optional list of field names to check
"""
for ref in _collect_refs(obj, fields):
updated... |
def _remove_by_pk(self, key, flush=True):
"""Retrieve value from store.
:param key: Key
"""
try:
del self.store[key]
except Exception as error:
pass
if flush:
self.flush() |
def eventhandler(*args, **kwargs):
"""
Decorator. Marks a function as a receiver for the specified slack event(s).
* events - String or list of events to handle
"""
def wrapper(func):
if isinstance(kwargs['events'], basestring):
kwargs['events'] = [kwargs['events']]
fu... |
def start(self):
"""Initializes the bot, plugins, and everything."""
self.bot_start_time = datetime.now()
self.webserver = Webserver(self.config['webserver']['host'], self.config['webserver']['port'])
self.plugins.load()
self.plugins.load_state()
self._find_event_handlers... |
def run(self, start=True):
"""
Connects to slack and enters the main loop.
* start - If True, rtm.start API is used. Else rtm.connect API is used
For more info, refer to
https://python-slackclient.readthedocs.io/en/latest/real_time_messaging.html#rtm-start-vs-rtm-connect
... |
def stop(self):
"""Does cleanup of bot and plugins."""
if self.webserver is not None:
self.webserver.stop()
if not self.test_mode:
self.plugins.save_state() |
def send_message(self, channel, text, thread=None, reply_broadcast=None):
"""
Sends a message to the specified channel
* channel - The channel to send to. This can be a SlackChannel object, a channel id, or a channel name
(without the #)
* text - String to send
* thread... |
def send_im(self, user, text):
"""
Sends a message to a user as an IM
* user - The user to send to. This can be a SlackUser object, a user id, or the username (without the @)
* text - String to send
"""
if isinstance(user, SlackUser):
user = user.id
... |
def token_is_correct(self, token):
"""
Подходит ли токен, для генерации текста.
Допускаются русские слова, знаки препинания и символы начала и конца.
"""
if self.is_rus_word(token):
return True
elif self.ONLY_MARKS.search(token):
return True
... |
def get_optimal_variant(self, variants, start_words, **kwargs):
"""
Возвращает оптимальный вариант, из выборки.
"""
if not start_words:
return (choice(variants), {})
_variants = []
_weights = []
for tok in frozenset(variants):
if not self... |
def start_generation(self, *start_words, **kwargs):
"""
Генерирует предложение.
:start_words: Попытаться начать предложение с этих слов.
"""
out_text = ""
_need_capialize = True
for token in self._get_generate_tokens(*start_words, **kwargs):
if token i... |
def get_start_array(self, *start_words, **kwargs):
"""
Генерирует начало предложения.
:start_words: Попытаться начать предложение с этих слов.
"""
if not self.start_arrays:
raise MarkovTextExcept("Не с чего начинать генерацию.")
if not start_words:
... |
def create_base(self):
"""
Метод создаёт базовый словарь, на основе массива токенов.
Вызывается из метода обновления.
"""
self.base_dict = {}
_start_arrays = []
for tokens, word in self.chain_generator():
self.base_dict.setdefault(tokens, []).append(wo... |
def chain_generator(self):
"""
Возвращает генератор, формата:
(("токен", ...), "вариант")
Где количество токенов определяет переменная объекта chain_order.
"""
n_chain = self.chain_order
if n_chain < 1:
raise MarkovTextExcept(
"... |
def set_vocabulary(self, peer_id, from_dialogue=None, update=False):
"""
Получает вокабулар из функции get_vocabulary и делает его активным.
"""
self.tokens_array = self.get_vocabulary(
peer_id,
from_dialogue,
update
)
self.create_base... |
def create_dump(self, name=None):
"""
Сохраняет текущую базу на жёсткий диск.
:name: Имя файла, без расширения.
"""
name = name or "vocabularDump"
backup_dump_file = os_join(
self.temp_folder,
"{0}.backup".format(name)
)
dump_file =... |
def load_dump(self, name=None):
"""
Загружает базу с жёсткого диска.
Текущая база заменяется.
:name: Имя файла, без расширения.
"""
name = name or "vocabularDump"
dump_file = os_join(
self.temp_folder,
"{0}.json".format(name)
)
... |
def get_vocabulary(self, target, user=None, update=False):
"""
Возвращает запас слов, на основе переписок ВК.
Для имитации речи конкретного человека.
Работает только с импортом объекта "Владя-бота".
:target:
Объект собседника. Источник переписки.
:user:
... |
def update(self, data, fromfile=True):
"""
Принимает текст, или путь к файлу и обновляет существующую базу.
"""
func = (self._parse_from_file if fromfile else self._parse_from_text)
new_data = tuple(func(data))
if new_data:
self.tokens_array += new_data
... |
def _parse_from_text(self, text):
"""
Возвращает генератор токенов, из текста.
"""
if not isinstance(text, str):
raise MarkovTextExcept("Передан не текст.")
text = text.strip().lower()
need_start_token = True
token = "$" # На случай, если переданная с... |
def _parse_from_file(self, file_path):
"""
см. описание _parse_from_text.
Только на вход подаётся не текст, а путь к файлу.
"""
file_path = abspath(file_path)
if not isfile(file_path):
raise MarkovTextExcept("Передан не файл.")
with open(file_path, "rb... |
def push(self, message):
"""
Takes a SlackEvent, parses it for a command, and runs against registered plugin
"""
if self._ignore_event(message):
return None, None
args = self._parse_message(message)
self.log.debug("Searching for command using chunks: %s", args... |
def _ignore_event(self, message):
"""
message_replied event is not truly a message event and does not have a message.text
don't process such events
commands may not be idempotent, so ignore message_changed events.
"""
if hasattr(message, 'subtype') and message.subtype in... |
def register_plugin(self, plugin):
"""Registers a plugin and commands with the dispatcher for push()"""
self.log.info("Registering plugin %s", type(plugin).__name__)
self._register_commands(plugin)
plugin.on_load() |
def acl_show(self, msg, args):
"""Show current allow and deny blocks for the given acl."""
name = args[0] if len(args) > 0 else None
if name is None:
return "%s: The following ACLs are defined: %s" % (msg.user, ', '.join(self._acl.keys()))
if name not in self._acl:
... |
def add_user_to_allow(self, name, user):
"""Add a user to the given acl allow block."""
# Clear user from both allow and deny before adding
if not self.remove_user_from_acl(name, user):
return False
if name not in self._acl:
return False
self._acl[name]... |
def remove_user_from_acl(self, name, user):
"""Remove a user from the given acl (both allow and deny)."""
if name not in self._acl:
return False
if user in self._acl[name]['allow']:
self._acl[name]['allow'].remove(user)
if user in self._acl[name]['deny']:
... |
def create_acl(self, name):
"""Create a new acl."""
if name in self._acl:
return False
self._acl[name] = {
'allow': [],
'deny': []
}
return True |
def delete_acl(self, name):
"""Delete an acl."""
if name not in self._acl:
return False
del self._acl[name]
return True |
def mongo(daemon=False, port=20771):
'''Run the mongod process.
'''
cmd = "mongod --port {0}".format(port)
if daemon:
cmd += " --fork"
run(cmd) |
def proxy_factory(BaseSchema, label, ProxiedClass, get_key):
"""Create a proxy to a class instance stored in ``proxies``.
:param class BaseSchema: Base schema (e.g. ``StoredObject``)
:param str label: Name of class variable to set
:param class ProxiedClass: Class to get or create
:param function ge... |
def with_proxies(proxy_map, get_key):
"""Class decorator factory; adds proxy class variables to target class.
:param dict proxy_map: Mapping between class variable labels and proxied
classes
:param function get_key: Extension-specific key function; may return e.g.
the current Flask request
... |
def _to_primary_key(self, value):
"""
Return primary key; if value is StoredObject, verify
that it is loaded.
"""
if value is None:
return None
if isinstance(value, self.base_class):
if not value._is_loaded:
raise exceptions.Databa... |
def set_nested(data, value, *keys):
"""Assign to a nested dictionary.
:param dict data: Dictionary to mutate
:param value: Value to set
:param list *keys: List of nested keys
>>> data = {}
>>> set_nested(data, 'hi', 'k0', 'k1', 'k2')
>>> data
{'k0': {'k1': {'k2': 'hi'}}}
"""
i... |
def get_by_username(self, username):
"""Retrieve user by username"""
res = filter(lambda x: x.username == username, self.users.values())
if len(res) > 0:
return res[0]
return None |
def set(self, user):
"""
Adds a user object to the user manager
user - a SlackUser object
"""
self.log.info("Loading user information for %s/%s", user.id, user.username)
self.load_user_info(user)
self.log.info("Loading user rights for %s/%s", user.id, user.usern... |
def load_user_rights(self, user):
"""Sets permissions on user object"""
if user.username in self.admins:
user.is_admin = True
elif not hasattr(user, 'is_admin'):
user.is_admin = False |
def send_message(self, channel, text):
"""
Used to send a message to the specified channel.
* channel - can be a channel or user
* text - message to send
"""
if isinstance(channel, SlackIM) or isinstance(channel, SlackUser):
self._bot.send_im(channel, text)
... |
def start_timer(self, duration, func, *args):
"""
Schedules a function to be called after some period of time.
* duration - time in seconds to wait before firing
* func - function to be called
* args - arguments to pass to the function
"""
t = threading.Timer(dur... |
def stop_timer(self, func):
"""
Stops a timer if it hasn't fired yet
* func - the function passed in start_timer
"""
if func in self._timer_callbacks:
t = self._timer_callbacks[func]
t.cancel()
del self._timer_callbacks[func] |
def get_user(self, username):
"""
Utility function to query slack for a particular user
:param username: The username of the user to lookup
:return: SlackUser object or None
"""
if hasattr(self._bot, 'user_manager'):
user = self._bot.user_manager.get_by_usern... |
def print_res(data):
""" Print translate result in a better format
Args:
data(str): result
"""
print('===================================')
main_part = data['data']
print(main_part['word_name'])
symbols = main_part['symbols'][0]
print("美式音标：[" + symbols['ph_am'] + "]")
print(... |
def cmd(admin_only=False, acl='*', aliases=None, while_ignored=False, *args, **kwargs):
"""
Decorator to mark plugin functions as commands in the form of !<cmd_name>
* admin_only - indicates only users in bot_admin are allowed to execute (only used if AuthManager is loaded)
* acl - indicates which ACL ... |
def webhook(*args, **kwargs):
"""
Decorator to mark plugin functions as entry points for web calls
* route - web route to register, uses Flask syntax
* method - GET/POST, defaults to POST
"""
def wrapper(func):
func.is_webhook = True
func.route = args[0]
func.form_params... |
def _get_underlying_data(self, instance):
"""Return data from raw data store, rather than overridden
__get__ methods. Should NOT be overwritten.
"""
self._touch(instance)
return self.data.get(instance, None) |
def freeze(value):
""" Cast value to its frozen counterpart. """
if isinstance(value, list):
return FrozenList(*value)
if isinstance(value, dict):
return FrozenDict(**value)
return value |
def help(self, msg, args):
"""Displays help for each command"""
output = []
if len(args) == 0:
commands = sorted(self._bot.dispatcher.commands.items(), key=itemgetter(0))
commands = filter(lambda x: x[1].is_subcmd is False, commands)
# Filter commands if auth ... |
def save(self, msg, args):
"""Causes the bot to write its current state to backend."""
self.send_message(msg.channel, "Saving current state...")
self._bot.plugins.save_state()
self.send_message(msg.channel, "Done.") |
def shutdown(self, msg, args):
"""Causes the bot to gracefully shutdown."""
self.log.info("Received shutdown from %s", msg.user.username)
self._bot.runnable = False
return "Shutting down..." |
def whoami(self, msg, args):
"""Prints information about the user and bot version."""
output = ["Hello %s" % msg.user]
if hasattr(self._bot.dispatcher, 'auth_manager') and msg.user.is_admin is True:
output.append("You are a *bot admin*.")
output.append("Bot version: %s-%s" % ... |
def sleep(self, channel):
"""Causes the bot to ignore all messages from the channel.
Usage:
!sleep [channel name] - ignore the specified channel (or current if none specified)
"""
self.log.info('Sleeping in %s', channel)
self._bot.dispatcher.ignore(channel)
self.... |
def wake(self, channel):
"""Causes the bot to resume operation in the channel.
Usage:
!wake [channel name] - unignore the specified channel (or current if none specified)
"""
self.log.info('Waking up in %s', channel)
self._bot.dispatcher.unignore(channel)
self.se... |
def _arg_name(self, name, types, prefix="--"):
if 'type:a10_nullable' in types:
return self._arg_name(name, types['type:a10_nullable'], prefix)
if 'type:a10_list' in types:
return self._arg_name(name, types['type:a10_list'], prefix)
if 'type:a10_reference' in types:
... |
def _sort_by(key):
"""
High order function for sort methods.
"""
@staticmethod
def sort_by(p_list, reverse=False):
return sorted(
p_list,
key=lambda p: getattr(p, key),
reverse=reverse,
)
return sort_by |
def select(self, filters=all_true, recursive=True):
"""Select path by criterion.
:param filters: a lambda function that take a `pathlib.Path` as input,
boolean as a output.
:param recursive: include files in subfolder or not.
**中文文档**
根据filters中定义的条件选择路径。
"""... |
def select_file(self, filters=all_true, recursive=True):
"""Select file path by criterion.
**中文文档**
根据filters中定义的条件选择文件。
"""
for p in self.select(filters, recursive):
if p.is_file():
yield p |
def select_dir(self, filters=all_true, recursive=True):
"""Select dir path by criterion.
**中文文档**
根据filters中定义的条件选择文件夹。
"""
for p in self.select(filters, recursive):
if p.is_dir():
yield p |
def n_file(self):
"""
Count how many files in this directory. Including file in sub folder.
"""
self.assert_is_dir_and_exists()
n = 0
for _ in self.select_file(recursive=True):
n += 1
return n |
def n_dir(self):
"""
Count how many folders in this directory. Including folder in sub folder.
"""
self.assert_is_dir_and_exists()
n = 0
for _ in self.select_dir(recursive=True):
n += 1
return n |
def n_subfile(self):
"""
Count how many files in this directory (doesn't include files in
sub folders).
"""
self.assert_is_dir_and_exists()
n = 0
for _ in self.select_file(recursive=False):
n += 1
return n |
def n_subdir(self):
"""
Count how many folders in this directory (doesn't include folder in
sub folders).
"""
self.assert_is_dir_and_exists()
n = 0
for _ in self.select_dir(recursive=False):
n += 1
return n |
def select_by_ext(self, ext, recursive=True):
"""
Select file path by extension.
:param ext:
**中文文档**
选择与预定义的若干个扩展名匹配的文件。
"""
ext = [ext.strip().lower() for ext in ensure_list(ext)]
def filters(p): return p.suffix.lower() in ext
return self.se... |
def select_by_pattern_in_fname(self,
pattern,
recursive=True,
case_sensitive=False):
"""
Select file path by text pattern in file name.
**中文文档**
选择文件名中包含指定子字符串的文件。
"""
... |
def select_by_pattern_in_abspath(self,
pattern,
recursive=True,
case_sensitive=False):
"""
Select file path by text pattern in absolute path.
**中文文档**
选择绝对路径中包含指定子字符串的文件。
... |
def select_by_size(self, min_size=0, max_size=1 << 40, recursive=True):
"""
Select file path by size.
**中文文档**
选择所有文件大小在一定范围内的文件。
"""
def filters(p): return min_size <= p.size <= max_size
return self.select_file(filters, recursive) |
def select_by_mtime(self, min_time=0, max_time=ts_2100,
recursive=True):
"""
Select file path by modify time.
:param min_time: lower bound timestamp
:param max_time: upper bound timestamp
**中文文档**
选择所有 :attr:`pathlib_mate.pathlib2.Path.mtime` 在一... |
def select_by_atime(self, min_time=0, max_time=ts_2100, recursive=True):
"""
Select file path by access time.
:param min_time: lower bound timestamp
:param max_time: upper bound timestamp
**中文文档**
选择所有 :attr:`pathlib_mate.pathlib2.Path.atime` 在一定范围内的文件。
"""
... |
def select_by_ctime(self, min_time=0, max_time=ts_2100,
recursive=True):
"""
Select file path by create time.
:param min_time: lower bound timestamp
:param max_time: upper bound timestamp
**中文文档**
选择所有 :attr:`pathlib_mate.pathlib2.Path.ctime` 在一... |
def dirsize(self):
"""
Return total file size (include sub folder). Symlink doesn't count.
"""
total = 0
for p in self.select_file(recursive=True):
try:
total += p.size
except: # pragma: no cover
print("Unable to get file s... |
def make_zip_archive(self,
dst=None,
filters=all_true,
compress=True,
overwrite=False,
makedirs=False,
verbose=False): # pragma: no cover
"""
Make a zip ... |
def backup(self,
dst=None,
ignore=None,
ignore_ext=None,
ignore_pattern=None,
ignore_size_smaller_than=None,
ignore_size_larger_than=None,
case_sensitive=False): # pragma: no cover
"""
Create a comp... |
def acquire_lock(func):
"""Decorate methods when locking repository is required."""
@wraps(func)
def wrapper(self, *args, **kwargs):
with self.locker as r:
# get the result
acquired, code, _ = r
if acquired:
try:
r = func(self,... |
def sync_required(func):
"""Decorate methods when synchronizing repository is required."""
@wraps(func)
def wrapper(self, *args, **kwargs):
if not self._keepSynchronized:
r = func(self, *args, **kwargs)
else:
state = self._load_state()
#print("----------->... |
def get_pickling_errors(obj, seen=None):
"""Investigate pickling errors."""
if seen == None:
seen = []
if hasattr(obj, "__getstate__"):
state = obj.__getstate__()
#elif hasattr(obj, "__dict__"):
# state = obj.__dict__
else:
return None
#try:
# state = obj.__... |
def get_list_representation(self):
"""
Gets a representation of the Repository content in a list of directories(files) format.
:Returns:
#. repr (list): The list representation of the Repository content.
"""
if self.__path is None:
return []
repr ... |
def walk_files_relative_path(self, relativePath=""):
"""
Walk the repository and yield all found files relative path joined with file name.
:parameters:
#. relativePath (str): The relative path from which start the walk.
"""
def walk_files(directory, relativePath):
... |
def walk_files_info(self, relativePath=""):
"""
Walk the repository and yield tuples as the following:\n
(relative path to relativePath joined with file name, file info dict).
:parameters:
#. relativePath (str): The relative path from which start the walk.
"""
... |
def walk_directories_relative_path(self, relativePath=""):
"""
Walk repository and yield all found directories relative path
:parameters:
#. relativePath (str): The relative path from which start the walk.
"""
def walk_directories(directory, relativePath):
... |
def walk_directories_info(self, relativePath=""):
"""
Walk repository and yield all found directories relative path.
:parameters:
#. relativePath (str): The relative path from which start the walk.
"""
def walk_directories(directory, relativePath):
direct... |
def walk_directory_directories_relative_path(self, relativePath=""):
"""
Walk a certain directory in repository and yield all found directories relative path.
:parameters:
#. relativePath (str): The relative path of the directory.
"""
# get directory info dict
... |
def walk_directory_directories_info(self, relativePath=""):
"""
Walk a certain directory in repository and yield tuples as the following:\n
(relative path joined with directory name, file info dict).
:parameters:
#. relativePath (str): The relative path of the directory.
... |
def synchronize(self, verbose=False):
"""
Synchronizes the Repository information with the directory.
All registered but missing files and directories in the directory,
will be automatically removed from the Repository.
:parameters:
#. verbose (boolean): Whether to b... |
def load_repository(self, path):
"""
Load repository from a directory path and update the current instance.
:Parameters:
#. path (string): The path of the directory from where to load the repository.
If '.' or an empty string is passed, the current working directory w... |
def create_repository(self, path, info=None, verbose=True):
"""
create a repository in a directory.
This method insures the creation of the directory in the system if it is missing.\n
**N.B. This method erases existing pyrep repository in the path but not the repository files.**
... |
def get_repository(self, path, info=None, verbose=True):
"""
Create a repository at given real path or load any existing one.
This method insures the creation of the directory in the system if it is missing.\n
Unlike create_repository, this method doesn't erase any existing repository
... |
def remove_repository(self, path=None, relatedFiles=False, relatedFolders=False, verbose=True):
"""
Remove .pyrepinfo file from path if exists and related files and directories
when respective flags are set to True.
:Parameters:
#. path (None, string): The path of the direct... |
def save(self):
""" Save repository .pyrepinfo to disk. """
# open file
repoInfoPath = os.path.join(self.__path, ".pyrepinfo")
try:
fdinfo = open(repoInfoPath, 'wb')
except Exception as e:
raise Exception("unable to open repository info for saving (%s)"%e)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.