def __init__(self,
callback,
pass_update_queue=False,
pass_job_queue=False,
pattern=None,
pass_groups=False,
pass_groupdict=False,
pass_user_data=False,
pass_chat_data=False):
super(InlineQueryHandler, self).__init__(
callback,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
python类string_types()的实例源码
def __init__(self,
pattern,
callback,
pass_groups=False,
pass_groupdict=False,
pass_update_queue=False,
pass_job_queue=False):
super(StringRegexHandler, self).__init__(
callback, pass_update_queue=pass_update_queue, pass_job_queue=pass_job_queue)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
def __init__(self,
callback,
pass_update_queue=False,
pass_job_queue=False,
pattern=None,
pass_groups=False,
pass_groupdict=False,
pass_user_data=False,
pass_chat_data=False):
super(CallbackQueryHandler, self).__init__(
callback,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
def __init__(self,
callback,
pass_update_queue=False,
pass_job_queue=False,
pattern=None,
pass_groups=False,
pass_groupdict=False,
pass_user_data=False,
pass_chat_data=False):
super(InlineQueryHandler, self).__init__(
callback,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
def __init__(self,
pattern,
callback,
pass_groups=False,
pass_groupdict=False,
pass_update_queue=False,
pass_job_queue=False):
super(StringRegexHandler, self).__init__(
callback, pass_update_queue=pass_update_queue, pass_job_queue=pass_job_queue)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
def __init__(self,
callback,
pass_update_queue=False,
pass_job_queue=False,
pattern=None,
pass_groups=False,
pass_groupdict=False,
pass_user_data=False,
pass_chat_data=False):
super(CallbackQueryHandler, self).__init__(
callback,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
def check_update(self, update):
return isinstance(update, string_types) and bool(re.match(self.pattern, update))
def __init__(self,
pattern,
callback,
pass_groups=False,
pass_groupdict=False,
pass_update_queue=False,
pass_job_queue=False,
pass_user_data=False,
pass_chat_data=False,
allow_edited=False,
message_updates=True,
channel_post_updates=False):
super(RegexHandler, self).__init__(
callback,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
self.allow_edited = allow_edited
self.message_updates = message_updates
self.channel_post_updates = channel_post_updates
def sub_regions(regions, region):
"""
Get regions from a list the overlap with another region.
:param regions: List of :class:`~GenomicRegion`
:param region: :class:`~GenomicRegion` used for overlap calculation
"""
if isinstance(region, string_types):
region = GenomicRegion.from_string(region)
sr = []
start_ix = None
end_ix = None
for i, r in enumerate(regions):
if r.chromosome == region.chromosome and r.start <= region.end and r.end >= region.start:
if start_ix is None:
start_ix = i
end_ix = i
sr.append(r.copy())
else:
if end_ix is not None:
break
if start_ix is None or end_ix is None:
raise ValueError("Region not found in dataset! {}:{}-{}".format(region.chromosome, region.start, region.end))
return sr, start_ix, end_ix
def plot(self, region=None, ax=None, **kwargs):
if isinstance(region, string_types):
region = GenomicRegion.from_string(region)
if ax:
self.ax = ax
# set genome tick formatter
self.ax.xaxis.set_major_formatter(GenomeCoordFormatter(region))
self.ax.xaxis.set_major_locator(GenomeCoordLocator(nbins=5))
self.ax.xaxis.set_minor_locator(MinorGenomeCoordLocator(n=5))
self.ax.set_title(self.title)
self._plot(region, **kwargs)
self.ax.set_xlim(region.start, region.end)
return self.fig, self.ax
def to_version(version):
if isinstance(version, six.string_types):
return Version(remove_blank(version))
else:
return version
def __init__(self, op, version):
self.version = to_version(version)
if isinstance(op, six.string_types):
op = COMPMAP[op]
self.op = op
def match(self, version):
if self.version.vstring == 'all':
return True
if not version or not isinstance(version, (six.string_types, Version)):
return False
version = to_version(version)
return self.op(version, self.version)
def __init__(self, conds):
if isinstance(conds, CondGroup):
self.conds = conds.conds
elif isinstance(conds, VersionCond):
self.conds = [conds]
elif isinstance(conds, six.string_types):
self.conds = [VersionCond.from_str(x) for x in conds.split(',')]
elif not conds:
self.conds = []
else:
self.conds = [VersionCond(op, version) for op, version in conds]
def __init__(self, ranges):
if isinstance(ranges, six.string_types):
self.ranges = [CondGroup(x) for x in ranges.split('|')]
elif isinstance(ranges, (list, tuple)):
self.ranges = [CondGroup(x) for x in ranges]
elif not ranges:
self.ranges = []
else:
raise TypeError('unknown ranges type')
def should_skip(self, key=None, value=None):
"""
??????????????
"""
if isinstance(key, six.string_types):
key_lower = key.lower()
if any((exc in key_lower) for exc in self.excludes['partmatch']):
return True
if key in self.excludes['fullmatch']:
return True
return False
def __eq__(self, other):
if isinstance(other, Payload):
return other.content == self.content and other.pattern == self.pattern
elif isinstance(other, six.string_types):
return self.content == other
else:
return False
def build(cls, obj):
"""????????payload"""
if isinstance(obj, Payload):
return copy.deepcopy(obj)
elif isinstance(obj, six.string_types):
return cls(obj)
elif isinstance(obj, (tuple, list)):
return cls(*obj)
elif isinstance(obj, dict):
return cls(**obj)
def __init__(self,
command,
callback,
filters=None,
allow_edited=False,
pass_args=False,
pass_update_queue=False,
pass_job_queue=False,
pass_user_data=False,
pass_chat_data=False):
super(CommandHandler, self).__init__(
callback,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data)
if isinstance(command, string_types):
self.command = [command.lower()]
else:
self.command = [x.lower() for x in command]
self.filters = filters
self.allow_edited = allow_edited
self.pass_args = pass_args
# We put this up here instead of with the rest of checking code
# in check_update since we don't wanna spam a ton
if isinstance(self.filters, list):
warnings.warn('Using a list of filters in MessageHandler is getting '
'deprecated, please use bitwise operators (& and |) '
'instead. More info: https://git.io/vPTbc.')
def check_update(self, update):
"""Determines whether an update should be passed to this handlers :attr:`callback`.
Args:
update (:obj:`str`): An incomming command.
Returns:
:obj:`bool`
"""
return isinstance(update, string_types) and bool(re.match(self.pattern, update))
def __init__(self,
pattern,
callback,
pass_groups=False,
pass_groupdict=False,
pass_update_queue=False,
pass_job_queue=False,
pass_user_data=False,
pass_chat_data=False,
allow_edited=False,
message_updates=True,
channel_post_updates=False,
edited_updates=False
):
if not message_updates and not channel_post_updates and not edited_updates:
raise ValueError(
'message_updates, channel_post_updates and edited_updates are all False')
if allow_edited:
warnings.warn('allow_edited is getting deprecated, please use edited_updates instead')
edited_updates = allow_edited
super(RegexHandler, self).__init__(
callback,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data)
if isinstance(pattern, string_types):
pattern = re.compile(pattern)
self.pattern = pattern
self.pass_groups = pass_groups
self.pass_groupdict = pass_groupdict
self.allow_edited = allow_edited
self.message_updates = message_updates
self.channel_post_updates = channel_post_updates
self.edited_updates = edited_updates
def __init__(self, user_id=None, username=None):
if not (bool(user_id) ^ bool(username)):
raise ValueError('One and only one of user_id or username must be used')
if user_id is not None and isinstance(user_id, int):
self.user_ids = [user_id]
else:
self.user_ids = user_id
if username is None:
self.usernames = username
elif isinstance(username, string_types):
self.usernames = [username.replace('@', '')]
else:
self.usernames = [user.replace('@', '') for user in username]
def __init__(self, chat_id=None, username=None):
if not (bool(chat_id) ^ bool(username)):
raise ValueError('One and only one of chat_id or username must be used')
if chat_id is not None and isinstance(chat_id, int):
self.chat_ids = [chat_id]
else:
self.chat_ids = chat_id
if username is None:
self.usernames = username
elif isinstance(username, string_types):
self.usernames = [username.replace('@', '')]
else:
self.usernames = [chat.replace('@', '') for chat in username]
def __init__(self, lang):
if isinstance(lang, string_types):
self.lang = [lang]
else:
self.lang = lang
self.name = 'Filters.language({})'.format(self.lang)
def asParser(fob, interpolation=None):
"""ConfigParser from a .ini filename or open file object. Idempotent."""
if isinstance(fob, ConfigParser):
return fob
if interpolation is True:
parser = ConfigParser()
else:
parser = ConfigParser(interpolation=interpolation)
if isinstance(fob, string_types):
parser.read(fob)
else:
parser.readfp(fob)
return parser
def get_database_id(cls, uri):
"""Parse a URI to extract the database ID"""
if isinstance(uri, string_types):
if not uri.startswith('local:') or '/' not in uri:
return
uriclsname, num = uri[6:].split('/', 1)
uricls = get_named_class(uriclsname)
if not uricls:
return
if uricls == cls or uricls in cls.mro() or cls in uricls.mro():
try:
return int(num)
except ValueError:
pass
def _json_is_known_instance(json_record, object_importer):
if isinstance(json_record, string_types):
identifier = json_record
json_record = None
elif isinstance(json_record, dict):
identifier = json_record.get('@id', None)
if identifier:
if object_importer is not None:
instance = object_importer.get_existing(identifier)
else:
instance = get_named_object(identifier)
return instance
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, EnumSymbol):
return value.value
elif isinstance(value, string_types):
# Should not happen, but mask the error for now.
return value
def value_to_class(self, value, base_class):
if isinstance(value, string_types):
return BaseTableEnum.__members__.get(value, None)
elif isinstance(value, type):
return value
else:
raise RuntimeError("Wrong value")
def get_login_context(request, force_show_providers=False):
slug = request.matchdict.get('discussion_slug', None)
if slug:
request.session['discussion'] = slug
else:
request.session.pop('discussion')
discussion = discussion_from_request(request)
get_routes = create_get_route(request, discussion)
providers = get_provider_data(get_routes)
hide_registration = (discussion
and not public_roles.intersection(set(roles_with_permissions(
discussion, P_READ)))
and not roles_with_permissions(
discussion, P_SELF_REGISTER_REQUEST, P_SELF_REGISTER))
if not force_show_providers:
hide_providers = aslist(request.registry.settings.get(
'hide_login_providers', ()))
if isinstance(hide_providers, string_types):
hide_providers = (hide_providers, )
providers = [p for p in providers if p['type'] not in hide_providers]
return dict(get_default_context(request),
providers=providers,
providers_json=json.dumps(providers),
saml_providers=request.registry.settings.get(
'SOCIAL_AUTH_SAML_ENABLED_IDPS', {}),
hide_registration=hide_registration,
identifier = request.params.get('identifier', ''),
google_consumer_key=request.registry.settings.get(
'google.consumer_key', ''),
next=handle_next_view(request),
get_route=get_routes)
