content
stringlengths 7
928k
| avg_line_length
float64 3.5
33.8k
| max_line_length
int64 6
139k
| alphanum_fraction
float64 0.08
0.96
| licenses
sequence | repository_name
stringlengths 7
104
| path
stringlengths 4
230
| size
int64 7
928k
| lang
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|
from __future__ import annotations
from asyncio import iscoroutine
from contextlib import AsyncExitStack
from typing import Any, Callable
import attr
from anyio import create_task_group
from anyio.abc import TaskGroup
from ..abc import AsyncEventBroker
from ..events import Event
from ..util import reentrant
from .base import BaseEventBroker
@reentrant
@attr.define(eq=False)
class LocalAsyncEventBroker(AsyncEventBroker, BaseEventBroker):
_task_group: TaskGroup = attr.field(init=False)
_exit_stack: AsyncExitStack = attr.field(init=False)
async def __aenter__(self) -> LocalAsyncEventBroker:
self._exit_stack = AsyncExitStack()
self._task_group = create_task_group()
await self._exit_stack.enter_async_context(self._task_group)
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
del self._task_group
async def publish(self, event: Event) -> None:
await self.publish_local(event)
async def publish_local(self, event: Event) -> None:
event_type = type(event)
one_shot_tokens: list[object] = []
for token, subscription in self._subscriptions.items():
if subscription.event_types is None or event_type in subscription.event_types:
self._task_group.start_soon(self._deliver_event, subscription.callback, event)
if subscription.one_shot:
one_shot_tokens.append(subscription.token)
for token in one_shot_tokens:
super().unsubscribe(token)
async def _deliver_event(self, func: Callable[[Event], Any], event: Event) -> None:
try:
retval = func(event)
if iscoroutine(retval):
await retval
except BaseException:
self._logger.exception('Error delivering %s event', event.__class__.__name__)
| 33.859649 | 94 | 0.701036 | [
"MIT"
] | agronholm/apscheduler | src/apscheduler/eventbrokers/async_local.py | 1,930 | Python |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-03-07 15:18
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
def add_author_to_blog(apps, schema_editor): # pylint: disable=unused-argument
"""Author is the claimant"""
Blog = apps.get_model("lowfat", "Blog") # pylint: disable=invalid-name
for blog in Blog.objects.all():
blog.author = blog.fund.claimant
blog.save()
class Migration(migrations.Migration):
dependencies = [
('lowfat', '0089_auto_20170306_1706'),
]
operations = [
migrations.AddField(
model_name='blog',
name='author',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='lowfat.Claimant'),
),
migrations.AddField(
model_name='historicalblog',
name='author',
field=models.ForeignKey(blank=True, db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to='lowfat.Claimant'),
),
migrations.AlterField(
model_name='blog',
name='fund',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='lowfat.Fund'),
),
migrations.RunPython(add_author_to_blog),
]
| 35.615385 | 168 | 0.645788 | [
"BSD-3-Clause"
] | elena-kolomeets/lowfat | lowfat/migrations/0090_auto_20170307_1518.py | 1,389 | Python |
from __future__ import annotations
from abc import abstractmethod
from typing import Any, Generic, Optional, TypeVar
from goodboy.errors import Error
from goodboy.messages import DEFAULT_MESSAGES, MessageCollectionType, type_name
from goodboy.schema import Rule, SchemaWithUtils
N = TypeVar("N")
class NumericBase(Generic[N], SchemaWithUtils):
"""
Abstract base class for Int/Float schemas, should not be used directly. Use
:class:`Int` or :class:`Float` instead.
"""
def __init__(
self,
*,
allow_none: bool = False,
messages: MessageCollectionType = DEFAULT_MESSAGES,
rules: list[Rule] = [],
less_than: Optional[N] = None,
less_or_equal_to: Optional[N] = None,
greater_than: Optional[N] = None,
greater_or_equal_to: Optional[N] = None,
allowed: Optional[list[N]] = None,
):
super().__init__(allow_none=allow_none, messages=messages, rules=rules)
self._less_than = less_than
self._less_or_equal_to = less_or_equal_to
self._greater_than = greater_than
self._greater_or_equal_to = greater_or_equal_to
self._allowed = allowed
def _validate(
self, value: Any, typecast: bool, context: dict[str, Any] = {}
) -> tuple[Optional[N], list[Error]]:
value, type_errors = self._validate_exact_type(value)
if type_errors:
return None, type_errors
errors = []
if self._allowed is not None and value not in self._allowed:
errors.append(self._error("not_allowed", {"allowed": self._allowed}))
if self._less_than is not None and value >= self._less_than:
errors.append(
self._error("greater_or_equal_to", {"value": self._less_than})
)
if self._less_or_equal_to is not None and value > self._less_or_equal_to:
errors.append(
self._error("greater_than", {"value": self._less_or_equal_to})
)
if self._greater_than is not None and value <= self._greater_than:
errors.append(
self._error("less_or_equal_to", {"value": self._greater_than})
)
if self._greater_or_equal_to is not None and value < self._greater_or_equal_to:
errors.append(
self._error("less_than", {"value": self._greater_or_equal_to})
)
value, rule_errors = self._call_rules(value, typecast, context)
return value, errors + rule_errors
@abstractmethod
def _validate_exact_type(self, value: Any) -> tuple[Optional[N], list[Error]]:
...
class Float(NumericBase[float]):
"""
Accept ``float`` values. Integer values are converted to floats.
When type casting enabled, strings and other values with magic method
`__float__ <https://docs.python.org/3/reference/datamodel.html#object.__float__>`_
are converted to floats.
:param allow_none: If true, value is allowed to be ``None``.
:param messages: Override error messages.
:param rules: Custom validation rules.
:param less_than: Accept only values less than option value.
:param less_or_equal_to: Accept only values less than or equal to option value.
:param greater_than: Accept only values greater than option value.
:param greater_or_equal_to: Accept only values greater than or equal to option
value.
:param allowed: Allow only certain values.
"""
def _typecast(
self, input: Any, context: dict[str, Any] = {}
) -> tuple[Optional[float], list[Error]]:
if isinstance(input, float):
return input, []
if isinstance(input, int):
return float(input), []
if not isinstance(input, str):
return None, [
self._error("unexpected_type", {"expected_type": type_name("float")})
]
try:
return float(input), []
except ValueError:
return None, [self._error("invalid_numeric_format")]
def _validate_exact_type(self, value: Any) -> tuple[Optional[float], list[Error]]:
if isinstance(value, float):
return value, []
elif isinstance(value, int):
return float(value), []
else:
return None, [
self._error("unexpected_type", {"expected_type": type_name("float")})
]
class Int(NumericBase[int]):
"""
Accept ``int`` values.
When type casting enabled, strings and other values with magic method
`__int__ <https://docs.python.org/3/reference/datamodel.html#object.__int__>`_ are
converted to integers.
:param allow_none: If true, value is allowed to be ``None``.
:param messages: Override error messages.
:param rules: Custom validation rules.
:param less_than: Accept only values less than option value.
:param less_or_equal_to: Accept only values less than or equal to option value.
:param greater_than: Accept only values greater than option value.
:param greater_or_equal_to: Accept only values greater than or equal to option
value.
:param allowed: Allow only certain values.
"""
def _typecast(
self, input: Any, context: dict[str, Any] = {}
) -> tuple[Optional[int], list[Error]]:
if isinstance(input, int):
return input, []
if not isinstance(input, str):
return None, [
self._error("unexpected_type", {"expected_type": type_name("int")})
]
try:
return int(input), []
except ValueError:
return None, [self._error("invalid_integer_format")]
def _validate_exact_type(self, value: Any) -> tuple[Optional[int], list[Error]]:
if not isinstance(value, int):
return None, [
self._error("unexpected_type", {"expected_type": type_name("int")})
]
else:
return value, []
| 34.929825 | 87 | 0.630169 | [
"MIT"
] | andryunin/goodboy | src/goodboy/types/numeric.py | 5,973 | Python |
#!/usr/bin/env python
# Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""A tool to extract a build, executed by a buildbot slave.
"""
import optparse
import os
import shutil
import sys
import traceback
import urllib
from common import chromium_utils
from slave import build_directory
from slave import slave_utils
class ExtractHandler(object):
def __init__(self, url, archive_name):
self.url = url
self.archive_name = archive_name
class GSHandler(ExtractHandler):
def download(self):
status = slave_utils.GSUtilCopy(self.url, '.')
if 0 != status:
return False
try:
shutil.move(os.path.basename(self.url), self.archive_name)
except OSError:
os.remove(self.archive_name)
shutil.move(os.path.basename(self.url), self.archive_name)
return True
class WebHandler(ExtractHandler):
@chromium_utils.RunAndPrintDots
def download(self):
try:
rc = urllib.urlretrieve(self.url, self.archive_name)
print '\nDownload complete'
except IOError:
print '\nFailed to download build'
return False
return rc
def GetBuildUrl(options, build_revision, webkit_revision=None):
"""Compute the url to download the build from. This will use as a base
string, in order of preference:
0) options.build_archive_url
1) options.build_url
2) options.factory_properties.build_url
3) build url constructed from build_properties. This last type of
construction is not compatible with the 'force build' button.
Args:
options: options object as specified by parser below.
build_revision: Revision for the build.
webkit_revision: WebKit revision (optional)
"""
if options.build_archive_url:
return options.build_archive_url, None
base_filename, version_suffix = slave_utils.GetZipFileNames(
options.master_name,
options.build_number,
options.parent_build_number,
build_revision, webkit_revision, extract=True)
replace_dict = {
'base_filename': base_filename,
'parentname': options.parent_builder_name,
'parentslavename': options.parent_slave_name,
'parent_builddir': options.parent_build_dir,
}
# If builddir isn't specified, assume buildbot used the builder name
# as the root folder for the build.
if not replace_dict.get('parent_builddir') and replace_dict.get('parentname'):
replace_dict['parent_builddir'] = replace_dict.get('parentname', '')
url = options.build_url
if not url:
url = ('http://%(parentslavename)s/b/build/slave/%(parent_builddir)s/'
'chrome_staging')
if url[-4:] != '.zip': # assume filename not specified
# Append the filename to the base URL. First strip any trailing slashes.
url = url.rstrip('/')
url = '%s/%s' % (url, '%(base_filename)s.zip')
url = url % replace_dict
archive_name = url.split('/')[-1]
versioned_url = url.replace('.zip', version_suffix + '.zip')
return versioned_url, archive_name
def real_main(options):
""" Download a build, extract it to build\\BuildDir\\full-build-win32
and rename it to build\\BuildDir\\Target
"""
abs_build_dir = os.path.abspath(
build_directory.GetBuildOutputDirectory(options.src_dir))
target_build_output_dir = os.path.join(abs_build_dir, options.target)
# Generic name for the archive.
archive_name = 'full-build-%s.zip' % chromium_utils.PlatformName()
# Just take the zip off the name for the output directory name.
output_dir = os.path.join(abs_build_dir, archive_name.replace('.zip', ''))
src_dir = os.path.dirname(abs_build_dir)
if not options.build_revision and not options.build_archive_url:
(build_revision, webkit_revision) = slave_utils.GetBuildRevisions(
src_dir, options.webkit_dir, options.revision_dir)
else:
build_revision = options.build_revision
webkit_revision = options.webkit_revision
url, archive_name = GetBuildUrl(options, build_revision, webkit_revision)
if archive_name is None:
archive_name = 'build.zip'
base_url = None
else:
base_url = '/'.join(url.split('/')[:-1] + [archive_name])
if url.startswith('gs://'):
handler = GSHandler(url=url, archive_name=archive_name)
else:
handler = WebHandler(url=url, archive_name=archive_name)
# We try to download and extract 3 times.
for tries in range(1, 4):
print 'Try %d: Fetching build from %s...' % (tries, url)
failure = False
# If the url is valid, we download the file.
if not failure:
if not handler.download():
if options.halt_on_missing_build:
return slave_utils.ERROR_EXIT_CODE
failure = True
# If the versioned url failed, we try to get the latest build.
if failure:
if url.startswith('gs://') or not base_url:
continue
else:
print 'Fetching latest build at %s' % base_url
base_handler = handler.__class__(base_url, handler.archive_name)
if not base_handler.download():
continue
print 'Extracting build %s to %s...' % (archive_name, abs_build_dir)
try:
chromium_utils.RemoveDirectory(target_build_output_dir)
chromium_utils.ExtractZip(archive_name, abs_build_dir)
# For Chrome builds, the build will be stored in chrome-win32.
if 'full-build-win32' in output_dir:
chrome_dir = output_dir.replace('full-build-win32', 'chrome-win32')
if os.path.exists(chrome_dir):
output_dir = chrome_dir
print 'Moving build from %s to %s' % (output_dir, target_build_output_dir)
shutil.move(output_dir, target_build_output_dir)
except (OSError, IOError, chromium_utils.ExternalError):
print 'Failed to extract the build.'
# Print out the traceback in a nice format
traceback.print_exc()
# Try again...
continue
# If we got the latest build, then figure out its revision number.
if failure:
print "Trying to determine the latest build's revision number..."
try:
build_revision_file_name = os.path.join(
target_build_output_dir,
chromium_utils.FULL_BUILD_REVISION_FILENAME)
build_revision_file = open(build_revision_file_name, 'r')
print 'Latest build is revision: %s' % build_revision_file.read()
build_revision_file.close()
except IOError:
print "Could not determine the latest build's revision number"
if failure:
# We successfully extracted the archive, but it was the generic one.
return slave_utils.WARNING_EXIT_CODE
return 0
# If we get here, that means that it failed 3 times. We return a failure.
return slave_utils.ERROR_EXIT_CODE
def main():
option_parser = optparse.OptionParser()
option_parser.add_option('--target',
help='build target to archive (Debug or Release)')
option_parser.add_option('--src-dir', default='src',
help='path to the top-level sources directory')
option_parser.add_option('--build-dir', help='ignored')
option_parser.add_option('--master-name', help='Name of the buildbot master.')
option_parser.add_option('--build-number', type=int,
help='Buildbot build number.')
option_parser.add_option('--parent-build-dir',
help='Path to build directory on parent buildbot '
'builder.')
option_parser.add_option('--parent-builder-name',
help='Name of parent buildbot builder.')
option_parser.add_option('--parent-slave-name',
help='Name of parent buildbot slave.')
option_parser.add_option('--parent-build-number', type=int,
help='Buildbot parent build number.')
option_parser.add_option('--build-url',
help='Base url where to find the build to extract')
option_parser.add_option('--build-archive-url',
help='Exact url where to find the build to extract')
# TODO(cmp): Remove --halt-on-missing-build when the buildbots are upgraded
# to not use this argument.
option_parser.add_option('--halt-on-missing-build', action='store_true',
help='whether to halt on a missing build')
option_parser.add_option('--build_revision',
help='Revision of the build that is being '
'archived. Overrides the revision found on '
'the local disk')
option_parser.add_option('--webkit_revision',
help='Webkit revision of the build that is being '
'archived. Overrides the revision found on '
'the local disk')
option_parser.add_option('--webkit-dir', help='WebKit directory path, '
'relative to the src/ dir.')
option_parser.add_option('--revision-dir',
help=('Directory path that shall be used to decide '
'the revision number for the archive, '
'relative to the src/ dir.'))
option_parser.add_option('--build-output-dir', help='ignored')
chromium_utils.AddPropertiesOptions(option_parser)
options, args = option_parser.parse_args()
if args:
print 'Unknown options: %s' % args
return 1
if not options.master_name:
options.master_name = options.build_properties.get('mastername', '')
if not options.build_number:
options.build_number = options.build_properties.get('buildnumber')
if not options.parent_build_dir:
options.parent_build_dir = options.build_properties.get('parent_builddir')
if not options.parent_builder_name:
options.parent_builder_name = options.build_properties.get('parentname')
if not options.parent_slave_name:
options.parent_slave_name = options.build_properties.get('parentslavename')
if not options.parent_build_number:
options.parent_build_number = options.build_properties.get(
'parent_buildnumber')
if not options.build_url:
options.build_url = options.factory_properties.get('build_url')
if not options.halt_on_missing_build:
options.halt_on_missing_build = options.factory_properties.get(
'halt_on_missing_build')
if not options.target:
options.target = options.factory_properties.get('target', 'Release')
if not options.webkit_dir:
options.webkit_dir = options.factory_properties.get('webkit_dir')
if not options.revision_dir:
options.revision_dir = options.factory_properties.get('revision_dir')
options.src_dir = (options.factory_properties.get('extract_build_src_dir')
or options.src_dir)
return real_main(options)
if '__main__' == __name__:
sys.exit(main())
| 39.400722 | 80 | 0.678761 | [
"BSD-3-Clause"
] | bopopescu/build | scripts/slave/extract_build.py | 10,914 | Python |
#!/Users/fahmi.abdulaziz/PycharmProjects/tmdb/bin/python3.8
# -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import argparse
import os
import libcst as cst
import pathlib
import sys
from typing import (Any, Callable, Dict, List, Sequence, Tuple)
def partition(
predicate: Callable[[Any], bool],
iterator: Sequence[Any]
) -> Tuple[List[Any], List[Any]]:
"""A stable, out-of-place partition."""
results = ([], [])
for i in iterator:
results[int(predicate(i))].append(i)
# Returns trueList, falseList
return results[1], results[0]
class osloginCallTransformer(cst.CSTTransformer):
CTRL_PARAMS: Tuple[str] = ('retry', 'timeout', 'metadata')
METHOD_TO_PARAMS: Dict[str, Tuple[str]] = {
'delete_posix_account': ('name', ),
'delete_ssh_public_key': ('name', ),
'get_login_profile': ('name', 'project_id', 'system_id', ),
'get_ssh_public_key': ('name', ),
'import_ssh_public_key': ('parent', 'ssh_public_key', 'project_id', ),
'update_ssh_public_key': ('name', 'ssh_public_key', 'update_mask', ),
}
def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.CSTNode:
try:
key = original.func.attr.value
kword_params = self.METHOD_TO_PARAMS[key]
except (AttributeError, KeyError):
# Either not a method from the API or too convoluted to be sure.
return updated
# If the existing code is valid, keyword args come after positional args.
# Therefore, all positional args must map to the first parameters.
args, kwargs = partition(lambda a: not bool(a.keyword), updated.args)
if any(k.keyword.value == "request" for k in kwargs):
# We've already fixed this file, don't fix it again.
return updated
kwargs, ctrl_kwargs = partition(
lambda a: a.keyword.value not in self.CTRL_PARAMS,
kwargs
)
args, ctrl_args = args[:len(kword_params)], args[len(kword_params):]
ctrl_kwargs.extend(cst.Arg(value=a.value, keyword=cst.Name(value=ctrl))
for a, ctrl in zip(ctrl_args, self.CTRL_PARAMS))
request_arg = cst.Arg(
value=cst.Dict([
cst.DictElement(
cst.SimpleString("'{}'".format(name)),
cst.Element(value=arg.value)
)
# Note: the args + kwargs looks silly, but keep in mind that
# the control parameters had to be stripped out, and that
# those could have been passed positionally or by keyword.
for name, arg in zip(kword_params, args + kwargs)]),
keyword=cst.Name("request")
)
return updated.with_changes(
args=[request_arg] + ctrl_kwargs
)
def fix_files(
in_dir: pathlib.Path,
out_dir: pathlib.Path,
*,
transformer=osloginCallTransformer(),
):
"""Duplicate the input dir to the output dir, fixing file method calls.
Preconditions:
* in_dir is a real directory
* out_dir is a real, empty directory
"""
pyfile_gen = (
pathlib.Path(os.path.join(root, f))
for root, _, files in os.walk(in_dir)
for f in files if os.path.splitext(f)[1] == ".py"
)
for fpath in pyfile_gen:
with open(fpath, 'r') as f:
src = f.read()
# Parse the code and insert method call fixes.
tree = cst.parse_module(src)
updated = tree.visit(transformer)
# Create the path and directory structure for the new file.
updated_path = out_dir.joinpath(fpath.relative_to(in_dir))
updated_path.parent.mkdir(parents=True, exist_ok=True)
# Generate the updated source file at the corresponding path.
with open(updated_path, 'w') as f:
f.write(updated.code)
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description="""Fix up source that uses the oslogin client library.
The existing sources are NOT overwritten but are copied to output_dir with changes made.
Note: This tool operates at a best-effort level at converting positional
parameters in client method calls to keyword based parameters.
Cases where it WILL FAIL include
A) * or ** expansion in a method call.
B) Calls via function or method alias (includes free function calls)
C) Indirect or dispatched calls (e.g. the method is looked up dynamically)
These all constitute false negatives. The tool will also detect false
positives when an API method shares a name with another method.
""")
parser.add_argument(
'-d',
'--input-directory',
required=True,
dest='input_dir',
help='the input directory to walk for python files to fix up',
)
parser.add_argument(
'-o',
'--output-directory',
required=True,
dest='output_dir',
help='the directory to output files fixed via un-flattening',
)
args = parser.parse_args()
input_dir = pathlib.Path(args.input_dir)
output_dir = pathlib.Path(args.output_dir)
if not input_dir.is_dir():
print(
f"input directory '{input_dir}' does not exist or is not a directory",
file=sys.stderr,
)
sys.exit(-1)
if not output_dir.is_dir():
print(
f"output directory '{output_dir}' does not exist or is not a directory",
file=sys.stderr,
)
sys.exit(-1)
if os.listdir(output_dir):
print(
f"output directory '{output_dir}' is not empty",
file=sys.stderr,
)
sys.exit(-1)
fix_files(input_dir, output_dir)
| 34.576923 | 88 | 0.630701 | [
"MIT"
] | fahmi-aa/tmdb | bin/fixup_oslogin_v1_keywords.py | 6,293 | Python |
# coding:utf-8
from django import forms
from django.conf import settings
from django.contrib.admin.widgets import AdminTextareaWidget
from django.template.loader import render_to_string
from django.utils.safestring import mark_safe
from django.utils.http import urlencode
from . import settings as USettings
from .commands import *
from django.utils.six import string_types
# 修正输入的文件路径,输入路径的标准格式：abc,不需要前后置的路径符号
# 如果输入的路径参数是一个函数则执行，否则可以拉接受时间格式化，用来生成如file20121208.bmp的重命名格式
def calc_path(OutputPath, instance=None):
if callable(OutputPath):
try:
OutputPath = OutputPath(instance)
except:
OutputPath = ""
else:
try:
import datetime
OutputPath = datetime.datetime.now().strftime(OutputPath)
except:
pass
return OutputPath
# width=600, height=300, toolbars="full", imagePath="", filePath="", upload_settings={},
# settings={},command=None,event_handler=None
class UEditorWidget(forms.Textarea):
def __init__(self, attrs=None):
params = attrs.copy()
width = params.pop("width")
height = params.pop("height")
toolbars = params.pop("toolbars", "full")
imagePath = params.pop("imagePath", "")
filePath = params.pop("filePath", "")
upload_settings = params.pop("upload_settings", {})
settings = params.pop("settings", {})
command = params.pop("command", None)
event_handler = params.pop("event_handler", None)
# 扩展命令
self.command = command
self.event_handler = event_handler
# 上传路径
self.upload_settings = upload_settings.copy()
self.upload_settings.update({
"imagePathFormat": imagePath,
"filePathFormat": filePath
})
# 保存
self._upload_settings = self.upload_settings.copy()
self.recalc_path(None)
self.ueditor_settings = {
'toolbars': toolbars,
'initialFrameWidth': width,
'initialFrameHeight': height
}
# 以下处理工具栏设置，将normal,mini等模式名称转化为工具栏配置值
if toolbars == "full":
del self.ueditor_settings['toolbars']
elif isinstance(toolbars, string_types) and toolbars in USettings.TOOLBARS_SETTINGS:
self.ueditor_settings[
"toolbars"] = USettings.TOOLBARS_SETTINGS[toolbars]
else:
self.ueditor_settings["toolbars"] = toolbars
# raise ValueError('toolbars should be a string defined in DjangoUeditor.settings.TOOLBARS_SETTINGS, options are full(default), besttome, mini and normal!')
self.ueditor_settings.update(settings)
super(UEditorWidget, self).__init__(attrs)
def recalc_path(self, model_inst):
"""计算上传路径,允许是function"""
try:
uSettings = self.upload_settings
if 'filePathFormat' in self._upload_settings:
uSettings['filePathFormat'] = calc_path(
self._upload_settings['filePathFormat'], model_inst)
if 'imagePathFormat' in self._upload_settings:
uSettings['imagePathFormat'] = calc_path(
self._upload_settings['imagePathFormat'], model_inst)
if 'scrawlPathFormat' in self._upload_settings:
uSettings['scrawlPathFormat'] = calc_path(
self._upload_settings['scrawlPathFormat'], model_inst)
if 'videoPathFormat' in self._upload_settings:
uSettings['videoPathFormat'] = calc_path(
self._upload_settings['videoPathFormat'], model_inst),
if 'snapscreenPathFormat' in self._upload_settings:
uSettings['snapscreenPathFormat'] = calc_path(
self._upload_settings['snapscreenPathFormat'], model_inst)
if 'catcherPathFormat' in self._upload_settings:
uSettings['catcherPathFormat'] = calc_path(
self._upload_settings['catcherPathFormat'], model_inst)
if 'imageManagerListPath' in self._upload_settings:
uSettings['imageManagerListPath'] = calc_path(
self._upload_settings['imageManagerListPath'], model_inst)
if 'fileManagerListPath' in self._upload_settings:
uSettings['fileManagerListPath'] = calc_path(
self._upload_settings['fileManagerListPath'], model_inst)
# 设置默认值，未指定涂鸦、截图、远程抓图、图片目录时,默认均等于imagePath
if uSettings['imagePathFormat'] != "":
default_path = uSettings['imagePathFormat']
uSettings['scrawlPathFormat'] = uSettings.get(
'scrawlPathFormat', default_path)
uSettings['videoPathFormat'] = uSettings.get(
'videoPathFormat', default_path)
uSettings['snapscreenPathFormat'] = uSettings.get(
'snapscreenPathFormat', default_path)
uSettings['catcherPathFormat'] = uSettings.get(
'catcherPathFormat', default_path)
uSettings['imageManagerListPath'] = uSettings.get(
'imageManagerListPath', default_path)
if uSettings['filePathFormat'] != "":
uSettings['fileManagerListPath'] = uSettings.get(
'fileManagerListPath', uSettings['filePathFormat'])
except:
pass
def render(self, name, value, attrs=None, renderer=None):
if value is None:
value = ''
# 传入模板的参数
editor_id = "id_%s" % name.replace("-", "_")
uSettings = {
"name": name,
"id": editor_id,
"value": value
}
if isinstance(self.command, list):
cmdjs = ""
if isinstance(self.command, list):
for cmd in self.command:
cmdjs = cmdjs + cmd.render(editor_id)
else:
cmdjs = self.command.render(editor_id)
uSettings["commands"] = cmdjs
uSettings["settings"] = self.ueditor_settings.copy()
uSettings["settings"].update({
"serverUrl": "/ueditor/controller/?%s" % urlencode(self._upload_settings)
})
# 生成事件侦听
if self.event_handler:
uSettings["bindEvents"] = self.event_handler.render(editor_id)
context = {
'UEditor': uSettings,
'STATIC_URL': settings.STATIC_URL,
'STATIC_ROOT': settings.STATIC_ROOT,
'MEDIA_URL': settings.MEDIA_URL,
'MEDIA_ROOT': settings.MEDIA_ROOT
}
return mark_safe(render_to_string('ueditor.html', context))
class Media:
js = ("ueditor/ueditor.config.js",
"ueditor/ueditor.all.min.js")
class AdminUEditorWidget(AdminTextareaWidget, UEditorWidget):
def __init__(self, **kwargs):
super(AdminUEditorWidget, self).__init__(**kwargs)
| 39.220339 | 168 | 0.610631 | [
"MIT"
] | Jeyrce/ishare | DjangoUeditor/widgets.py | 7,260 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import cv2
import numpy as np
from math import cos, sin, pi
from tqdm import tqdm
import open3d as o3d
def render(pointcloud_file_path, estimate_normals_radius, estimate_normals_max_nn):
pointcloud = o3d.io.read_point_cloud(pointcloud_file_path, print_progress=True)
pointcloud.estimate_normals(
search_param=o3d.geometry.KDTreeSearchParamHybrid(
radius=estimate_normals_radius,
max_nn=estimate_normals_max_nn))
o3d.visualization.draw_geometries([pointcloud])
return True
class Renderer(object):
def __init__(self):
self.vis = o3d.visualization.Visualizer()
self.render_center = None
self.euler_angle = [0, 0, 0]
return
def getRotationMatrixFromEulerAngle(self, euler_angle):
R_x = np.array([
[1, 0, 0],
[0, cos(euler_angle[0]), -sin(euler_angle[0])],
[0, sin(euler_angle[0]), cos(euler_angle[0])]
])
R_y = np.array([
[cos(euler_angle[1]), 0, sin(euler_angle[1])],
[0, 1, 0],
[-sin(euler_angle[1]), 0, cos(euler_angle[1])]
])
R_z = np.array([
[cos(euler_angle[2]), -sin(euler_angle[2]), 0],
[sin(euler_angle[2]), cos(euler_angle[2]), 0],
[0, 0, 1]
])
rotation_matrix = np.dot(R_z, np.dot(R_y, R_x))
return rotation_matrix
def getRotateDirection(self, direction_vector, euler_angle):
np_direction_vector = np.array(direction_vector)
direction_vector_norm = np.linalg.norm(np_direction_vector)
if direction_vector_norm == 0:
print("[ERROR][Renderer::getRotateDirection]")
print("\t direction_vector_norm is 0!")
return None
np_unit_direction_vector = np_direction_vector / direction_vector_norm
rotation_matrix = self.getRotationMatrixFromEulerAngle(euler_angle)
rotate_direction = np.dot(rotation_matrix, np_unit_direction_vector)
return rotate_direction.tolist()
def rotateVis(self, delta_rotate_angle):
self.euler_angle[0] = 0
self.euler_angle[1] = -10 * pi / 180.0
self.euler_angle[2] += delta_rotate_angle * pi / 180.0
ctr = self.vis.get_view_control()
front_direction = self.getRotateDirection(
[1, 0, 0], self.euler_angle)
ctr.set_front(front_direction)
up_direction = self.getRotateDirection(
[0, 0, 1], self.euler_angle)
ctr.set_up(up_direction)
ctr.set_lookat(self.render_center)
# ctr.set_zoom(0.5)
return True
def render(self, show_labels, scene_pointcloud_file_path=None):
delta_rotate_angle = 0.5
if scene_pointcloud_file_path is not None:
print("start reading floor and wall...")
self.splitLabeledPoints(scene_pointcloud_file_path)
rendered_pointcloud = o3d.geometry.PointCloud()
render_points = []
render_colors = []
print("start create rendered pointcloud...")
for i in tqdm(range(len(self.pointcloud_list))):
points = np.asarray(self.pointcloud_list[i].points).tolist()
if len(points) == 0:
continue
for point in points:
render_points.append(point)
render_colors.append(self.d3_40_colors_rgb[i % len(self.d3_40_colors_rgb)] / 255.0)
if scene_pointcloud_file_path is not None:
print("start create rendered floor...")
for wall_point in tqdm(self.labeled_point_cluster_list[0]):
if abs(wall_point[2]) > 0.01:
continue
render_points.append(wall_point)
render_colors.append(np.array([132, 133, 135], dtype=np.uint8) / 255.0)
rendered_pointcloud.points = o3d.utility.Vector3dVector(np.array(render_points))
rendered_pointcloud.colors = o3d.utility.Vector3dVector(np.array(render_colors))
rendered_pointcloud.estimate_normals(
search_param=o3d.geometry.KDTreeSearchParamHybrid(radius=0.1, max_nn=30))
self.render_center = rendered_pointcloud.get_axis_aligned_bounding_box().get_center()
self.vis.create_window(window_name="Open3D RenderObject")
render_option = self.vis.get_render_option()
render_option.background_color = np.array([1, 1, 1])
render_option.point_size = 1
self.vis.add_geometry(rendered_pointcloud)
while True:
self.rotateVis(delta_rotate_angle)
# self.vis.update_geometry()
self.vis.poll_events()
self.vis.update_renderer()
if ord('q') == cv2.waitKey(1):
break
self.vis.destroy_window()
return True
def saveRender(self, output_video_file_path):
fps = 30
video_width = 1920
video_height = 1080
delta_rotate_angle = 0.5
if scene_pointcloud_file_path is not None:
print("start reading floor and wall...")
self.splitLabeledPoints(scene_pointcloud_file_path)
rendered_pointcloud = o3d.geometry.PointCloud()
render_points = []
render_colors = []
print("start create rendered pointcloud...")
for i in tqdm(range(len(self.pointcloud_list))):
points = np.asarray(self.pointcloud_list[i].points).tolist()
if len(points) == 0:
continue
for point in points:
render_points.append(point)
render_colors.append(self.d3_40_colors_rgb[i % len(self.d3_40_colors_rgb)] / 255.0)
if scene_pointcloud_file_path is not None:
print("start create rendered floor...")
for wall_point in tqdm(self.labeled_point_cluster_list[0]):
if abs(wall_point[2]) > 0.01:
continue
render_points.append(wall_point)
render_colors.append(np.array([132, 133, 135], dtype=np.uint8) / 255.0)
rendered_pointcloud.points = o3d.utility.Vector3dVector(np.array(render_points))
rendered_pointcloud.colors = o3d.utility.Vector3dVector(np.array(render_colors))
self.render_center = rendered_pointcloud.get_axis_aligned_bounding_box().get_center()
self.vis.create_window(window_name="Open3D RenderObject")
render_option = self.vis.get_render_option()
render_option.background_color = np.array([1, 1, 1])
render_option.point_size = 1
self.vis.add_geometry(rendered_pointcloud)
fourcc = cv2.VideoWriter_fourcc(*'MP4V')
out = cv2.VideoWriter(output_video_file_path, fourcc, fps, (video_width, video_height))
for i in range(int(360 / delta_rotate_angle)):
self.rotateVis(0.5)
# self.vis.update_geometry()
self.vis.poll_events()
self.vis.update_renderer()
open3d_image = np.asarray(self.vis.capture_screen_float_buffer()) * 255.0
cv_image = cv2.cvtColor(open3d_image, cv2.COLOR_RGB2BGR).astype(np.uint8)
out.write(cv_image)
self.vis.destroy_window()
out.release()
return True
| 37.148718 | 99 | 0.633214 | [
"MIT"
] | 565353780/pointcloud-manage | PointCloudClass/renderer.py | 7,244 | Python |
from raven.utils.testutils import TestCase
from raven.utils.wsgi import get_headers, get_host, get_environ, get_client_ip
class GetHeadersTest(TestCase):
def test_tuple_as_key(self):
result = dict(get_headers({
('a', 'tuple'): 'foo',
}))
self.assertEquals(result, {})
def test_coerces_http_name(self):
result = dict(get_headers({
'HTTP_ACCEPT': 'text/plain',
}))
self.assertIn('Accept', result)
self.assertEquals(result['Accept'], 'text/plain')
def test_coerces_content_type(self):
result = dict(get_headers({
'CONTENT_TYPE': 'text/plain',
}))
self.assertIn('Content-Type', result)
self.assertEquals(result['Content-Type'], 'text/plain')
def test_coerces_content_length(self):
result = dict(get_headers({
'CONTENT_LENGTH': '134',
}))
self.assertIn('Content-Length', result)
self.assertEquals(result['Content-Length'], '134')
class GetEnvironTest(TestCase):
def test_has_remote_addr(self):
result = dict(get_environ({'REMOTE_ADDR': '127.0.0.1'}))
self.assertIn('REMOTE_ADDR', result)
self.assertEquals(result['REMOTE_ADDR'], '127.0.0.1')
def test_has_server_name(self):
result = dict(get_environ({'SERVER_NAME': '127.0.0.1'}))
self.assertIn('SERVER_NAME', result)
self.assertEquals(result['SERVER_NAME'], '127.0.0.1')
def test_has_server_port(self):
result = dict(get_environ({'SERVER_PORT': 80}))
self.assertIn('SERVER_PORT', result)
self.assertEquals(result['SERVER_PORT'], 80)
def test_hides_wsgi_input(self):
result = list(get_environ({'wsgi.input': 'foo'}))
self.assertNotIn('wsgi.input', result)
class GetHostTest(TestCase):
def test_http_x_forwarded_host(self):
result = get_host({'HTTP_X_FORWARDED_HOST': 'example.com'})
self.assertEquals(result, 'example.com')
def test_http_host(self):
result = get_host({'HTTP_HOST': 'example.com'})
self.assertEquals(result, 'example.com')
def test_http_strips_port(self):
result = get_host({
'wsgi.url_scheme': 'http',
'SERVER_NAME': 'example.com',
'SERVER_PORT': '80',
})
self.assertEquals(result, 'example.com')
def test_https_strips_port(self):
result = get_host({
'wsgi.url_scheme': 'https',
'SERVER_NAME': 'example.com',
'SERVER_PORT': '443',
})
self.assertEquals(result, 'example.com')
def test_http_nonstandard_port(self):
result = get_host({
'wsgi.url_scheme': 'http',
'SERVER_NAME': 'example.com',
'SERVER_PORT': '81',
})
self.assertEquals(result, 'example.com:81')
class GetClientIpTest(TestCase):
def test_has_remote_addr(self):
result = get_client_ip({'REMOTE_ADDR': '127.0.0.1'})
self.assertEquals(result, '127.0.0.1')
def test_xff(self):
result = get_client_ip({'HTTP_X_FORWARDED_FOR': '1.1.1.1, 127.0.0.1'})
self.assertEquals(result, '1.1.1.1')
| 32.824742 | 78 | 0.612437 | [
"BSD-3-Clause"
] | 0-wiz-0/raven-python | tests/utils/wsgi/tests.py | 3,184 | Python |
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
'''Test for parse_ebi.py.
Run "python3 parse_ebi_test.py"
'''
import copy
import unittest
import parse_ebi
CONST_TEST_TEXT = '''[Term]
id: MI:0001
name: interaction detection method
def: "Method to determine the interaction." [PMID:14755292]
[Term]
id: MI:0045
name: experimental interaction detection
def: "Methods based" [PMID:14755292]
is_a: MI:0001 ! interaction detection method
[Term]
id: MI:0401
name: biochemical
def: "The application" [PMID:14755292]
is_a: MI:0045 ! experimental interaction detection
[Term]
id: MI:0091
name: chromatography technology
def: "Used to separate" [PMID:14755292]
is_a: MI:0401 ! biochemical'''
CONST_ID_TO_CLASS_NAME = {'MI:0001': 'InteractionDetectionMethod',
'MI:0091': 'ChromatographyTechnology',
'MI:0045': 'ExperimentalInteractionDetection', 'MI:0401': 'Biochemical'}
CONST_ID_TO_NODE = {}
CONST_ID_TO_NODE_NO_RELATION = {}
for key in ['MI:0001', 'MI:0045', 'MI:0401', 'MI:0091']:
CONST_ID_TO_NODE[key] = parse_ebi.Node(key)
CONST_ID_TO_NODE_NO_RELATION[key] = parse_ebi.Node(key)
CONST_ID_TO_NODE['MI:0001'].child_list.append(CONST_ID_TO_NODE['MI:0045'])
CONST_ID_TO_NODE['MI:0045'].parent_list.append(CONST_ID_TO_NODE['MI:0001'])
CONST_ID_TO_NODE['MI:0045'].child_list.append(CONST_ID_TO_NODE['MI:0401'])
CONST_ID_TO_NODE['MI:0401'].parent_list.append(CONST_ID_TO_NODE['MI:0045'])
CONST_ID_TO_NODE['MI:0401'].child_list.append(CONST_ID_TO_NODE['MI:0091'])
CONST_ID_TO_NODE['MI:0091'].parent_list.append(CONST_ID_TO_NODE['MI:0401'])
CONST_SCHEMA1 = '''Node: dcid:ExperimentalInteractionDetection
typeOf: dcs:InteractionTypeEnum
name: "ExperimentalInteractionDetection"
psimiID: "MI:0045"
description: "Methods base"
pubMedID: "14755292"
descriptionUrl: "http://psidev.info/groups/controlled-vocabularies"'''
CONST_SCHEMA2 = '''Node: dcid:Biochemical
typeOf: dcs:InteractionTypeEnum
name: "Biochemical"
psimiID: "MI:0401"
description: "The applicatio"
pubMedID: "14755292"
specializationOf: dcs:ExperimentalInteractionDetection
descriptionUrl: "http://psidev.info/groups/controlled-vocabularies"'''
def get_file_terms(file):
"Ruturns a list of text blocks."
file_terms = file.split('\n\n')
file_terms = [term_text.split('\n') for term_text in file_terms
if term_text.startswith('[Term]')]
return file_terms
CONST_FILE_TERMS = get_file_terms(CONST_TEST_TEXT)
CONST_INTERACTION_TYPE_ID_SET = set(['MI:0045', 'MI:0091', 'MI:0401'])
class TestParseEbi(unittest.TestCase):
"""Test the functions in parse_ebi.py"""
def test_get_id_maps(self):
"""Test function get_id_maps. Note that id_to_node here doesn't have parent_child
relation, so only map keys are tested."""
id_to_class_name, id_to_node = parse_ebi.get_id_maps(CONST_FILE_TERMS)
self.assertEqual(id_to_class_name, CONST_ID_TO_CLASS_NAME)
self.assertEqual(id_to_node.keys(), CONST_ID_TO_NODE_NO_RELATION.keys())
def test_build_child_parent_link(self):
"""Test function build_child_parent_link by checking the values of
child_list and parent_list."""
id_to_node = copy.deepcopy(CONST_ID_TO_NODE_NO_RELATION)
id_to_node = parse_ebi.build_child_parent_link(CONST_FILE_TERMS, id_to_node)
def get_node_value_set(node_list):
value_set = set()
for node in node_list:
value_set.add(node.value)
return value_set
for id_key in id_to_node:
parent_value_set = get_node_value_set(id_to_node[id_key].parent_list)
const_parent_value_set = get_node_value_set(CONST_ID_TO_NODE[id_key].parent_list)
child_value_set = get_node_value_set(id_to_node[id_key].child_list)
const_child_value_set = get_node_value_set(CONST_ID_TO_NODE[id_key].child_list)
self.assertEqual(parent_value_set, const_parent_value_set)
self.assertEqual(child_value_set, const_child_value_set)
def test_TreeBuilder(self):
"""Test TreeBuilder class."""
dfs_caller = parse_ebi.TreeBuilder(CONST_ID_TO_NODE)
INTERACTION_TYPE_ROOT = 'MI:0001'
interaction_type_id_set = dfs_caller.get_subset_id(INTERACTION_TYPE_ROOT)
self.assertEqual(interaction_type_id_set, CONST_INTERACTION_TYPE_ID_SET)
def test_get_schema_from_text(self):
"""Test function get_schema_from_text by comparing the final schema."""
new_source_map = {'references':{}}
term = CONST_FILE_TERMS[1]
schema_res = parse_ebi.get_schema_from_text(term, CONST_ID_TO_NODE,
new_source_map, CONST_ID_TO_CLASS_NAME,
CONST_INTERACTION_TYPE_ID_SET, set(), set())
self.assertEqual(schema_res[0], CONST_SCHEMA1)
term = CONST_FILE_TERMS[2]
schema_res = parse_ebi.get_schema_from_text(term, CONST_ID_TO_NODE,
new_source_map, CONST_ID_TO_CLASS_NAME,
CONST_INTERACTION_TYPE_ID_SET, set(), set())
self.assertEqual(schema_res[0], CONST_SCHEMA2)
if __name__ == '__main__':
unittest.main()
| 41.528571 | 98 | 0.71259 | [
"Apache-2.0"
] | pradh/data | scripts/proteinInteractionEBI/parse_ebi_test.py | 5,814 | Python |
import socket
import sys
from config import ip, port
net = 0
sock = None
try:
if sys.argv[1] == '--connect':
sock = socket.socket()
try:
sock.connect((sys.argv[2], int(sys.argv[3])))
print('Подключение к игре установлено.')
except:
print(f'Неудалось подключиться к игре по адресу {sys.argv[2]}:{sys.argv[3]}')
net = 1
elif sys.argv[1] == '--server':
try:
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((ip, port))
server.listen(1)
print(f'Сервер запущен по адресу {ip}:{port}...')
sock, address = server.accept()
print(f'Клиент {address[0]}:{address[1]} подключился')
except:
print(f'Неудалось запустить сервер по адресу {ip}:{port}')
net = 2
else:
print(f'Неизвестный параметр \'{sys.argv[1]}\'')
except:
print('Запускается одиночная игра на одном экране')
| 31.709677 | 89 | 0.563581 | [
"MIT"
] | Mogekoff/nachess | server.py | 1,170 | Python |
from rest_framework import serializers
from .models import Student
class StudentSerializer(serializers.ModelSerializer):
class Meta:
model = Student
fields = ('__all__')
| 21.333333 | 53 | 0.729167 | [
"MIT"
] | RodrigoBLima/app-django-react | django_app/students/serializers.py | 192 | Python |
import os
import pathlib
from dotenv import load_dotenv, find_dotenv
from fpdf import FPDF
#envelope size: 110 by 145 mm
# Elliot Torres
# 4321 Loser Road
# La Crescenta, CA 91214
#
# Ryan Lee
# 1234 Boomer Road
# La Crescenta, CA 91214
load_dotenv(find_dotenv())
# types out address on envelope
def sendmail(
FULLNAME,
ADDRESS_LINE_ONE,
CITY,
STATE,
ZIPCODE,
PERSON=None,
ADDRESS_LINE_TWO=None
):
if PERSON is None:
sender_name = os.environ['sender_name']
sender_addr1 = os.environ['sender_addr1']
sender_addr2 = os.environ['sender_addr2']
else:
sender_name = PERSON.fullname
sender_addr1 = f'{PERSON.addrline1}'
sender_addr2 = f'{PERSON.city}, {PERSON.state} {PERSON.zipcode}'
pdf = FPDF('L', 'mm', (110, 145))
pdf.add_page()
pdf.set_font('Times', '', 9.8)
pdf.set_margins(0, 0, 0)
pdf.text(7, 7.5, sender_name)
pdf.text(7, 10.5, sender_addr1)
pdf.text(7, 13.5, sender_addr2)
pdf.set_font('Times', '', 14)
if ADDRESS_LINE_TWO is None:
pdf.text(44, 78, FULLNAME)
pdf.text(44, 82, ADDRESS_LINE_ONE)
pdf.text(44, 86, f'{CITY}, {STATE} {ZIPCODE}')
else:
pdf.text(44, 78, FULLNAME)
pdf.text(44, 82, f'{ADDRESS_LINE_ONE}, {ADDRESS_LINE_TWO}')
pdf.text(44, 86, f'{CITY}, {STATE} {ZIPCODE}')
# types out message on back fo envelope
pdf.add_page()
pdf.set_margins(0, 0, 0)
pdf.text(10, 78, f"Happy Birthday {FULLNAME}!")
pdf.text(10, 82, "Have a wonderful day and enjoy your sweet!")
pdf.text(10, 86, "-CVHS Bday Team")
envelope_file = pathlib.Path('envelope.pdf')
if envelope_file.exists():
envelope_file.unlink()
pdf.output('envelope.pdf', dest='F').encode('latin-1')
os.system("lp -d printer envelope.pdf")
| 25.5 | 72 | 0.634532 | [
"MIT"
] | Ahsoka/bdaybot | bdaybot/snailmail.py | 1,836 | Python |
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class BST:
def __init__(self, val):
self.val = val
self.left = None
self.right = None
# Average: O(log(n)) time | O(1) space
# Worst: O(n) time | O(1) space
def insert(self, val):
currentNode = self
while True:
if val < currentNode.val:
if currentNode.left is None:
currentNode.left = BST(val)
break
else:
currentNode = currentNode.left
else:
if currentNode.right is None:
currentNode.right = BST(val)
break
else:
currentNode = currentNode.right
return self
import sys
class Solution(object):
def isValidBST(self, root):
"""
:type root: TreeNode
:rtype: bool
"""
MAX = sys.maxint
MIN = -sys.maxint - 1
return self.isValidBSTHelper(root, MIN, MAX)
def isValidBSTHelper(self, root, minValue, maxValue):
if root is None:
return True
if root.left is None and root.right is None:
return minValue < root.val < maxValue
if root.val <= minValue or root.val >= maxValue:
return False
leftSubtreeIsValid = self.isValidBSTHelper(root.left, minValue, root.val)
rightSubtreeIsValid = self.isValidBSTHelper(root.right, root.val, maxValue)
return leftSubtreeIsValid and rightSubtreeIsValid
# driver/test code
# test_tree = BST(100).insert(5).insert(15).insert(5).insert(2).insert(1).insert(22) \
# .insert(1).insert(1).insert(3).insert(1).insert(1).insert(502).insert(55000) \
# .insert(204).insert(205).insert(207).insert(206).insert(208).insert(203) \
# .insert(-51).insert(-403).insert(1001).insert(57).insert(60).insert(4500)
test_tree = BST(2).insert(1).insert(4).insert(None).insert(None).insert(3).insert(6)
sol = Solution()
is_valid_bst = sol.isValidBST(test_tree)
print("Is BST valid ? - ", is_valid_bst) | 30.666667 | 86 | 0.578804 | [
"MIT"
] | Ajaykumar98/Algorithms | leetcode.com/python/98_Validate_Binary_Search_Tree.py | 2,208 | Python |
from enum import Enum
from typing import List, Optional, Type, Union
import click
from ..types import NotSet
class CSVOption(click.Choice):
def __init__(self, choices: Type[Enum]):
self.enum = choices
super().__init__(tuple(choices.__members__))
def convert(
self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
) -> List[Enum]:
items = [item for item in value.split(",") if item]
invalid_options = set(items) - set(self.choices)
if not invalid_options and items:
return [self.enum[item] for item in items]
# Sort to keep the error output consistent with the passed values
sorted_options = ", ".join(sorted(invalid_options, key=items.index))
available_options = ", ".join(self.choices)
self.fail(f"invalid choice(s): {sorted_options}. Choose from {available_options}")
not_set = NotSet()
class OptionalInt(click.types.IntRange):
def convert( # type: ignore
self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
) -> Union[int, NotSet]:
if value == "None":
return not_set
try:
int(value)
return super().convert(value, param, ctx)
except ValueError:
self.fail("%s is not a valid integer or None" % value, param, ctx)
| 33.95122 | 98 | 0.640805 | [
"MIT"
] | PrayagS/schemathesis | src/schemathesis/cli/options.py | 1,392 | Python |
import nltk
# nltk.download('stopwords') #if doesnt work download all these first
# nltk.download('punkt')
# nltk.download('averaged_perceptron_tagger')
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize, sent_tokenize
stop_words = set(stopwords.words('english'))
meaning_with_example = {
"CC" : "coordinating conjunction",
"CD" : "cardinal digit",
"DT" : "determiner",
"EX" : "existential there (like: “there is” … think of it like “there exists”)",
"FW" : "foreign word",
"IN" : "preposition/subordinating conjunction",
"JJ" : "adjective ‘big’",
"JJR": "adjective, comparative ‘bigger’",
"JJS": "adjective, superlative ‘biggest’",
"LS" : "list marker 1)",
"MD" : "modal could, will",
"NN" : "noun, singular ‘desk’",
"NNS": "noun plural ‘desks’",
"NNP": "proper noun, singular ‘Harrison’",
"NNPS": "proper noun, plural ‘Americans’",
"PDT": "predeterminer ‘all the kids’",
"POS": "possessive ending parent‘s",
"PRP": "personal pronoun I, he, she",
"PRP$": "possessive pronoun my, his, hers",
"RB" : "adverb very, silently,",
"RBR": "adverb, comparative better",
"RBS": "adverb, superlative best",
"RP" : "particle give up",
"TO" : "to go ‘to‘ the store.",
"UH" : "interjection errrrrrrrm",
"VB" : "verb, base form take",
"VBD": "verb, past tense took",
"VBG": "verb, gerund/present participle taking",
"VBN": "verb, past participle taken",
"VBP": "verb, sing. present, non-3d take",
"VBZ": "verb, 3rd person sing. present takes",
"WDT": "wh-determiner which",
"WP" : "wh-pronoun who, what",
"WP$": "possessive wh-pronoun whose",
"WRB": "wh-abverb where, when",
"," : "comma",
"." : "full stop"
}
meaning = {
"CC" : "coordinating conjunction",
"CD" : "cardinal digit",
"DT" : "determiner",
"EX" : "existential there",
"FW" : "foreign word",
"IN" : "preposition/subordinating conjunction",
"JJ" : "adjective",
"JJR": "adjective, comparative",
"JJS": "adjective, superlative",
"LS" : "list marker",
"MD" : "modal could, will",
"NN" : "noun singular",
"NNS": "noun plural",
"NNP": "proper noun, singular",
"NNPS": "proper noun, plural",
"PDT": "predeterminer",
"POS": "possessive ending",
"PRP": "personal pronoun",
"PRP$": "possessive pronoun",
"RB" : "adverb ",
"RBR": "adverb, comparative ",
"RBS": "adverb, superlative ",
"RP" : "particle ",
"TO" : "to go ‘to‘ the store.",
"UH" : "interjection",
"VB" : "verb base form ",
"VBD": "verb past tense ",
"VBG": "verb gerund/present participle",
"VBN": "verb past participle ",
"VBP": "verb sing. present",
"VBZ": "verb 3rd person sing. present ",
"WDT": "wh-determiner which",
"WP" : "wh-pronoun who, what",
"WP$": "possessive wh-pronoun whose",
"WRB": "wh-abverb where, when"
}
def get_part_of_speech(sentence):
cleaned=[]
tokenized = sent_tokenize(sentence)
for i in tokenized:
wordsList = nltk.word_tokenize(i)
wordsList = [w for w in wordsList if not w in stop_words]
tagged = nltk.pos_tag(wordsList)
for pair in tagged:
c_pair=[]
c_pair.append(pair[0])
try :
c_pair.append(meaning[pair[1]])
except :
c_pair.append("Punctuation")
cleaned.append(c_pair)
return cleaned
#print(get_part_of_speech("Sukanya, Rajib and Naba are my good friends.")) | 30.570093 | 81 | 0.642006 | [
"Apache-2.0"
] | ruchind159/grammar_correction | part_of_speech.py | 3,323 | Python |
from __future__ import print_function
import sys
from metapub import PubMedFetcher
from metapub import FindIt
# examples of different formats:
# 18612690: PubMedArticle with multiple AbstractText sections
# 1234567: PubMedArticle with no abstract whatsoever
# 20301546: PubMedBookArticle from GeneReviews
####
import logging
logging.getLogger("requests").setLevel(logging.WARNING)
logging.getLogger("eutils").setLevel(logging.WARNING)
ch = logging.StreamHandler()
logging.getLogger("metapub").setLevel(logging.INFO)
logging.getLogger("metapub").addHandler(ch)
####
try:
pmid = sys.argv[1]
except IndexError:
print('Supply a pubmed ID as the argument to this script.')
print('')
print('Example: python demo_pubmed.py 123456')
sys.exit()
article = PubMedFetcher().article_by_pmid(pmid)
print('')
print(article.pmid, article.title)
print('')
print('authors: %s' % ','.join(article.authors))
print('journal: %s' % article.journal)
print('')
excerpt = '(empty)' if article.abstract is None else article.abstract[:100] + '[...]'
print('abstract: %s' % excerpt)
print('')
print('pii:',str(article.pii))
print('doi:',str(article.doi))
print('pmc:',str(article.pmc))
print('volume:',str(article.volume))
print('issue:',str(article.issue))
print('pages:',str(article.pages))
print('year:',str(article.year))
print('')
print('MeSH headings: ')
for DUI in list(article.mesh.keys()):
print('\t', DUI, article.mesh[DUI]['descriptor_name'], article.mesh.get('qualifier_name', ''))
if article.publication_types:
print('\nPublication Type Information')
for pt in list(article.publication_types.keys()):
print('\t', pt, article.publication_types[pt])
if article.chemicals:
print('\nChemical List')
for DUI in list(article.chemicals.keys()):
print('\t', DUI, article.chemicals[DUI]['substance_name'])
if article.grants:
print('\nGrant Information')
for gr in grants:
print('\t', gr)
if article.history:
print('\nArticle History')
for hist in article.history:
print('\t', hist, article.history[hist])
print('')
print('FindIt results:')
source = FindIt(pmid=pmid)
print('\tdoi:', source.doi)
print('\turl:', source.url)
print('\tbackup:', source.backup_url)
print('\treason:', source.reason)
print(article.citation_html)
| 27.428571 | 98 | 0.707031 | [
"Apache-2.0"
] | DocMT/metapub | bin/demo_get_PubMedArticle_by_pmid.py | 2,304 | Python |
from skimage.measure import find_contours
from skimage import io
from skimage.color import rgb2gray
from matplotlib import pyplot as plt
image = io.imread('contour_finding_test.png')
# image = io.imread('FlowchartDiagram.png')
image = rgb2gray(image)
out = find_contours(image)
print(len(out))
# Find contours at a constant value of 0.8
# contours = find_contours(image, 0.8)
contours = find_contours(image, )
# Display the image and plot all contours found
fig, ax = plt.subplots()
ax.imshow(image, cmap=plt.cm.gray)
for contour in contours:
ax.plot(contour[:, 1], contour[:, 0], linewidth=2)
ax.axis('image')
ax.set_xticks([])
ax.set_yticks([])
plt.show()
# io.imshow(image)
# io.show()
| 24.068966 | 54 | 0.73639 | [
"Apache-2.0"
] | egonw/pyamiimage | pyimage/contour.py | 698 | Python |
import numpy as np
from numpy import (reciprocal, einsum, maximum, minimum, zeros_like,
atleast_1d, squeeze)
from scipy.linalg import eig, eigvals, matrix_balance, norm
from harold._classes import Transfer, transfer_to_state
from harold._discrete_funcs import discretize
from harold._arg_utils import _check_for_state, _check_for_state_or_transfer
__all__ = ['simulate_linear_system', 'simulate_step_response',
'simulate_impulse_response']
def simulate_linear_system(sys, u, t=None, x0=None, per_channel=False):
"""
Compute the linear model response to an input array sampled at given time
instances.
Parameters
----------
sys : {State, Transfer}
The system model to be simulated
u : array_like
The real-valued input sequence to force the model. 1D arrays for single
input models and 2D arrays that has as many columns as the number of
inputs are valid inputs.
t : array_like, optional
The real-valued sequence to be used for the evolution of the system.
The values should be equally spaced otherwise an error is raised. For
discrete time models increments different than the sampling period also
raises an error. On the other hand for discrete models this can be
omitted and a time sequence will be generated automatically.
x0 : array_like, optional
The initial condition array. If omitted an array of zeros is assumed.
Note that Transfer models by definition assume zero initial conditions
and will raise an error.
per_channel : bool, optional
If this is set to True and if the system has multiple inputs, the
response of each input is returned individually. For example, if a
system has 4 inputs and 3 outputs then the response shape becomes
(num, p, m) instead of (num, p) where k-th slice (:, :, k) is the
response from the k-th input channel. For single input systems, this
keyword has no effect.
Returns
-------
yout : ndarray
The resulting response array. The array is 1D if sys is SISO and
has p columns if sys has p outputs.
tout : ndarray
The time sequence used in the simulation. If the parameter t is not
None then a copy of t is given.
Notes
-----
For Transfer models, first conversion to a state model is performed and
then the resulting model is used for computations.
"""
_check_for_state_or_transfer(sys)
# Quick initial condition checks
if x0 is not None:
if sys._isgain:
raise ValueError('Static system models can\'t have initial '
'conditions set.')
if isinstance(sys, Transfer):
raise ValueError('Transfer models can\'t have initial conditions '
'set.')
x0 = np.asarray(x0, dtype=float).squeeze()
if x0.ndim > 1:
raise ValueError('Initial condition can only be a 1D array.')
else:
x0 = x0[:, None]
if sys.NumberOfStates != x0.size:
raise ValueError('The initial condition size does not match the '
'number of states of the model.')
# Always works with State Models
try:
_check_for_state(sys)
except ValueError:
sys = transfer_to_state(sys)
n, m = sys.NumberOfStates, sys.shape[1]
is_discrete = sys.SamplingSet == 'Z'
u = np.asarray(u, dtype=float).squeeze()
if u.ndim == 1:
u = u[:, None]
t = _check_u_and_t_for_simulation(m, sys._dt, u, t, is_discrete)
# input and time arrays are regular move on
# Static gains are simple matrix multiplications with no x0
if sys._isgain:
if sys._isSISO:
yout = u * sys.d.squeeze()
else:
# don't bother for single inputs
if m == 1:
per_channel = False
if per_channel:
yout = np.einsum('ij,jk->ikj', u, sys.d.T)
else:
yout = u @ sys.d.T
# Dynamic model
else:
# TODO: Add FOH discretization for funky input
# ZOH discretize the continuous system based on the time increment
if not is_discrete:
sys = discretize(sys, t[1]-t[0], method='zoh')
sample_num = len(u)
a, b, c, d = sys.matrices
# Bu and Du are constant matrices so get them ready (transposed)
M_u = np.block([b.T, d.T])
at = a.T
# Explicitly skip single inputs for per_channel
if m == 1:
per_channel = False
# Shape the response as a 3D array
if per_channel:
xout = np.empty([sample_num, n, m], dtype=float)
for col in range(m):
xout[0, :, col] = 0. if x0 is None else x0.T
Bu = u[:, [col]] @ b.T[[col], :]
# Main loop for xdot eq.
for row in range(1, sample_num):
xout[row, :, col] = xout[row-1, :, col] @ at + Bu[row-1]
# Get the output equation for each slice of inputs
# Cx + Du
yout = np.einsum('ijk,jl->ilk', xout, c.T) + \
np.einsum('ij,jk->ikj', u, d.T)
# Combined output
else:
BDu = u @ M_u
xout = np.empty([sample_num, n], dtype=float)
xout[0] = 0. if x0 is None else x0.T
# Main loop for xdot eq.
for row in range(1, sample_num):
xout[row] = (xout[row-1] @ at) + BDu[row-1, :n]
# Now we have all the state evolution get the output equation
yout = xout @ c.T + BDu[:, n:]
return yout, t
def simulate_step_response(sys, t=None):
"""
Compute the linear model response to an Heaviside function (or all-ones
array) sampled at given time instances.
If the time array is omitted then a time sequence is generated based on
the poles of the model.
Parameters
----------
sys : {State, Transfer}
The system model to be simulated
t : array_like
The real-valued sequence to be used for the evolution of the system.
The values should be equally spaced otherwise an error is raised. For
discrete time models increments different than the sampling period also
raises an error. On the other hand for discrete models this can be
omitted and a time sequence will be generated automatically.
Returns
-------
yout : ndarray
The resulting response array. The array is 1D if sys is SISO and
has p columns if sys has p outputs. If there are also m inputs the
array is 3D array with the shape (<num of samples>, p, m)
tout : ndarray
The time sequence used in the simulation. If the parameter t is not
None then a copy of t is given.
"""
_check_for_state_or_transfer(sys)
# Always works with State Models
try:
_check_for_state(sys)
except ValueError:
sys = transfer_to_state(sys)
if t is None:
tf, ts = _compute_tfinal_and_dt(sys)
t = np.arange(0, tf+ts, ts, dtype=float)
else:
t, ts = _check_custom_time_input(t)
m = sys.shape[1]
u = np.ones([len(t), m], dtype=float)
return simulate_linear_system(sys, u=u, t=t, per_channel=1)
def simulate_impulse_response(sys, t=None):
"""
Compute the linear model response to an Dirac delta pulse (or all-zeros
array except the first sample being 1/dt at each channel) sampled at given
time instances.
If the time array is omitted then a time sequence is generated based on
the poles of the model.
Parameters
----------
sys : {State, Transfer}
The system model to be simulated
t : array_like
The real-valued sequence to be used for the evolution of the system.
The values should be equally spaced otherwise an error is raised. For
discrete time models increments different than the sampling period also
raises an error. On the other hand for discrete models this can be
omitted and a time sequence will be generated automatically.
Returns
-------
yout : ndarray
The resulting response array. The array is 1D if sys is SISO and
has p columns if sys has p outputs. If there are also m inputs the
array is 3D array with the shape (<num of samples>, p, m)
tout : ndarray
The time sequence used in the simulation. If the parameter t is not
None then a copy of t is given.
"""
_check_for_state_or_transfer(sys)
# Always works with State Models
try:
_check_for_state(sys)
except ValueError:
sys = transfer_to_state(sys)
if t is None:
tf, ts = _compute_tfinal_and_dt(sys, is_step=False)
t = np.arange(0, tf+ts, ts, dtype=float)
else:
t, ts = _check_custom_time_input(t)
m = sys.shape[1]
u = np.zeros([len(t), m], dtype=float)
u[0] = 1./ts
return simulate_linear_system(sys, u=u, t=t, per_channel=1)
def _compute_tfinal_and_dt(sys, is_step=True):
"""
Helper function to estimate a final time and a sampling period for
time domain simulations. It is essentially geared towards impulse response
but is also used for step responses.
For discrete-time models, obviously dt is inherent and only tfinal is
computed.
Parameters
----------
sys : {State, Transfer}
The system to be investigated
is_step : bool
Scales the dc value by the magnitude of the nonzero mode since
integrating the impulse response gives ∫exp(-λt) = -exp(-λt)/λ.
Default is True.
Returns
-------
tfinal : float
The final time instance for which the simulation will be performed.
dt : float
The estimated sampling period for the simulation.
Notes
-----
Just by evaluating the fastest mode for dt and slowest for tfinal often
leads to unnecessary, bloated sampling (e.g., Transfer(1,[1,1001,1000]))
since dt will be very small and tfinal will be too large though the fast
mode hardly ever contributes. Similarly, change the numerator to [1, 2, 0]
and the simulation would be unnecessarily long and the plot is virtually
an L shape since the decay is so fast.
Instead, a modal decomposition in time domain hence a truncated ZIR and ZSR
can be used such that only the modes that have significant effect on the
time response are taken. But the sensitivity of the eigenvalues complicate
the matter since dλ = <w, dA*v> with <w,v> = 1. Hence we can only work
with simple poles with this formulation. See Golub, Van Loan Section 7.2.2
for simple eigenvalue sensitivity about the nonunity of <w,v>. The size of
the response is dependent on the size of the eigenshapes rather than the
eigenvalues themselves.
"""
sqrt_eps = np.sqrt(np.spacing(1.))
min_points = 100 # min number of points
min_points_z = 20 # min number of points
max_points = 10000 # max number of points
max_points_z = 75000 # max number of points for discrete models
default_tfinal = 5 # Default simulation horizon
total_cycles = 5 # number of cycles for oscillating modes
pts_per_cycle = 25 # Number of points divide a period of oscillation
log_decay_percent = np.log(100) # Factor of reduction for real pole decays
# if a static model is given, don't bother with checks
if sys._isgain:
if sys._isdiscrete:
return sys._dt*min_points_z, sys._dt
else:
return default_tfinal, default_tfinal / min_points
if sys._isdiscrete:
# System already has sampling fixed hence we can't fall into the same
# trap mentioned above. Just get nonintegrating slow modes together
# with the damping.
dt = sys._dt
tfinal = default_tfinal
p = eigvals(sys.a)
# Array Masks
# unstable
m_u = (np.abs(p) >= 1 + sqrt_eps)
p_u, p = p[m_u], p[~m_u]
if p_u.size > 0:
m_u = (p_u.real < 0) & (np.abs(p_u.imag) < sqrt_eps)
t_emp = np.max(log_decay_percent / np.abs(np.log(p_u[~m_u])/dt))
tfinal = max(tfinal, t_emp)
# zero - negligible effect on tfinal
m_z = np.abs(p) < sqrt_eps
p = p[~m_z]
# Negative reals- treated as oscillary mode
m_nr = (p.real < 0) & (np.abs(p.imag) < sqrt_eps)
p_nr, p = p[m_nr], p[~m_nr]
if p_nr.size > 0:
t_emp = np.max(log_decay_percent / np.abs((np.log(p_nr)/dt).real))
tfinal = max(tfinal, t_emp)
# discrete integrators
m_int = (p.real - 1 < sqrt_eps) & (np.abs(p.imag) < sqrt_eps)
p_int, p = p[m_int], p[~m_int]
# pure oscillatory modes
m_w = (np.abs(np.abs(p) - 1) < sqrt_eps)
p_w, p = p[m_w], p[~m_w]
if p_w.size > 0:
t_emp = total_cycles * 2 * np.pi / np.abs(np.log(p_w)/dt).min()
tfinal = max(tfinal, t_emp)
if p.size > 0:
t_emp = log_decay_percent / np.abs((np.log(p)/dt).real).min()
tfinal = max(tfinal, t_emp)
if p_int.size > 0:
tfinal = tfinal * 5
# Make tfinal an integer multiple of dt
num_samples = tfinal // dt
if num_samples > max_points_z:
tfinal = dt * max_points_z
else:
tfinal = dt * num_samples
return tfinal, dt
# Improve conditioning via balancing and zeroing tiny entries
# See <w,v> for [[1,2,0], [9,1,0.01], [1,2,10*np.pi]] before/after balance
b, (sca, perm) = matrix_balance(sys.a, separate=True)
p, l, r = eig(b, left=True, right=True)
# Reciprocal of inner product <w,v> for each λ, (bound the ~infs by 1e12)
# G = Transfer([1], [1,0,1]) gives zero sensitivity (bound by 1e-12)
eig_sens = reciprocal(maximum(1e-12, einsum('ij,ij->j', l, r).real))
eig_sens = minimum(1e12, eig_sens)
# Tolerances
p[np.abs(p) < np.spacing(eig_sens * norm(b, 1))] = 0.
# Incorporate balancing to outer factors
l[perm, :] *= reciprocal(sca)[:, None]
r[perm, :] *= sca[:, None]
w, v = sys.c @ r, l.T.conj() @ sys.b
origin = False
# Computing the "size" of the response of each simple mode
wn = np.abs(p)
if np.any(wn == 0.):
origin = True
dc = zeros_like(p, dtype=float)
# well-conditioned nonzero poles, np.abs just in case
ok = np.abs(eig_sens) <= 1/sqrt_eps
# the averaged t→∞ response of each simple λ on each i/o channel
# See, A = [[-1, k], [0, -2]], response sizes are k-dependent (that is
# R/L eigenvector dependent)
dc[ok] = norm(v[ok, :], axis=1)*norm(w[:, ok], axis=0)*eig_sens[ok]
dc[wn != 0.] /= wn[wn != 0] if is_step else 1.
dc[wn == 0.] = 0.
# double the oscillating mode magnitude for the conjugate
dc[p.imag != 0.] *= 2
# Now get rid of noncontributing integrators and simple modes if any
relevance = (dc > 0.1*dc.max()) | ~ok
psub = p[relevance]
wnsub = wn[relevance]
tfinal, dt = [], []
ints = wnsub == 0.
iw = (psub.imag != 0.) & (np.abs(psub.real) <= sqrt_eps)
# Pure imaginary?
if np.any(iw):
tfinal += (total_cycles * 2 * np.pi / wnsub[iw]).tolist()
dt += (2 * np.pi / pts_per_cycle / wnsub[iw]).tolist()
# The rest ~ts = log(%ss value) / exp(Re(λ)t)
texp_mode = log_decay_percent / np.abs(psub[~iw & ~ints].real)
tfinal += texp_mode.tolist()
dt += minimum(texp_mode / 50,
(2 * np.pi / pts_per_cycle / wnsub[~iw & ~ints])).tolist()
# All integrators?
if len(tfinal) == 0:
return default_tfinal*5, default_tfinal*5/min_points
tfinal = np.max(tfinal)*(5 if origin else 1)
dt = np.min(dt)
dt = tfinal / max_points if tfinal // dt > max_points else dt
tfinal = dt * min_points if tfinal // dt < min_points else tfinal
return tfinal, dt
def _check_u_and_t_for_simulation(m, dt, u, t, isdiscrete):
"""
Helper function to validate the input arguments for simulate_linear_system
"""
# Discrete models can omit t array, make one here for convenience
if t is None:
if not isdiscrete:
raise ValueError('Continuous time models need an evenly spaced '
'time sequence from which the sampling period '
'will be obtained.')
else:
u_samples = len(u)
t = np.linspace(0, (u_samples-1)*dt, num=u_samples)
else:
t = np.asarray(t, dtype=float).squeeze()
if t.ndim != 1:
raise ValueError('Time array needs to be a 1D array.')
t_diff = np.diff(t)
if not np.allclose(t_diff, t_diff[0]) or not t_diff[0] > 0.:
raise ValueError('Time array should be equally spaced and '
'increasing.')
if isdiscrete and not np.isclose(dt, t_diff[0]):
raise ValueError('Time array increment {} is not equal to the'
' model sampling period {}.'.format(t_diff[0],
dt))
if u.size < 1:
raise ValueError('The input array should at least have one point.')
# First dimension is always # of samples
if len(u) != len(t):
raise ValueError('The input and time arrays should have the same'
' length. t: {} vs. u: {}'.format(t.shape,
u.shape))
if u.shape[1] != m:
raise ValueError('Number of input columns ({}) don\'t match the number'
' of inputs ({}) of the given model.'
''.format(u.shape[1], m))
return t
def _check_custom_time_input(t):
"""
Helper function for simple and rather expensive checks for sanity
"""
t = atleast_1d(t)
if t.ndim > 1:
t = squeeze(t)
if t.ndim > 1:
raise ValueError('Time array should be a 1D array but has '
'{} nontrivial dimensions'.format(t.ndim))
if t.size < 2:
raise ValueError('Time array should have at least two data points.')
dt = t[1] - t[0]
if dt <= 0.:
raise ValueError('The time increment dt cannot be negative; '
'Difference of the first two samples t1 - t0 = {}'
''.format(dt))
# np.diff is somewhat slower than the diff of the views
if not np.allclose(t[1:] - t[:-1], dt):
raise ValueError('Supplied time array is not numerically equally '
'spaced (checked via numpy.allclose).')
return t, dt
| 37.602 | 79 | 0.604489 | [
"MIT"
] | TavaresFilipe/harold | harold/_time_domain.py | 18,814 | Python |
#
# Copyright 2020 Logical Clocks AB
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from hsfs import util
from hsfs.constructor import query
import humps
class Join:
INNER = "INNER"
LEFT = "LEFT"
RIGHT = "RIGHT"
FULL = "FULL"
CROSS = "CROSS"
LEFT_SEMI_JOIN = "LEFT_SEMI_JOIN"
COMMA = "COMMA"
def __init__(self, query, on, left_on, right_on, join_type, prefix):
self._query = query
self._on = util.parse_features(on)
self._left_on = util.parse_features(left_on)
self._right_on = util.parse_features(right_on)
self._join_type = join_type or self.INNER
self._prefix = prefix
def to_dict(self):
return {
"query": self._query,
"on": self._on,
"leftOn": self._left_on,
"rightOn": self._right_on,
"type": self._join_type,
"prefix": self._prefix,
}
@classmethod
def from_response_json(cls, json_dict):
json_decamelized = humps.decamelize(json_dict)
return cls(
query=query.Query.from_response_json(json_decamelized["query"]),
on=json_decamelized.get("on", None),
left_on=json_decamelized.get("left_on", None),
right_on=json_decamelized.get("right_on", None),
join_type=json_decamelized.get("join_type", None),
prefix=json_decamelized.get("prefix", None),
)
@property
def query(self):
return self._query
@query.setter
def query(self, query):
self._query = query
| 29.885714 | 76 | 0.640057 | [
"Apache-2.0"
] | DhananjayMukhedkar/feature-store-api | python/hsfs/constructor/join.py | 2,092 | Python |
import tensorflow as tf
import tensorflow.contrib.slim as slim
from tflearn.layers.conv import global_avg_pool
#######################
# 3d functions
#######################
# convolution
# 3D unet graph
def unet(inputI, output_channel):
"""3D U-net"""
phase_flag = 1
concat_dim = 4
conv1_1 = conv3d(
input=inputI,
output_chn=64,
kernel_size=3,
stride=1,
use_bias=False,
name='conv1')
# conv1_1 (1, 96, 96, 96, 64)
conv1_bn = tf.contrib.layers.batch_norm(
conv1_1,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=phase_flag,
scope="conv1_batch_norm")
conv1_relu = tf.nn.relu(conv1_bn, name='conv1_relu')
pool1_in = tf.layers.max_pooling3d(
inputs=conv1_relu, pool_size=2, strides=2, name='pool1')
# pool1 (1, 48, 48, 48, 64)
# pool1_frac = fractal_net(
# is_global_path_list[0],
# global_path_list[0],
# local_path_list[0],
# self.Blocks,
# self.Columns)(pool1_in)
# pool1_old = pool1_in + pool1_frac
pool1 = pool1_in
conv2_1 = conv3d(
input=pool1,
output_chn=128,
kernel_size=3,
stride=1,
use_bias=False,
name='conv2')
# (1, 48, 48, 48, 128)
conv2_bn = tf.contrib.layers.batch_norm(
conv2_1,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=phase_flag,
scope="conv2_batch_norm")
conv2_relu = tf.nn.relu(conv2_bn, name='conv2_relu')
pool2_in = tf.layers.max_pooling3d(
inputs=conv2_relu, pool_size=2, strides=2, name='pool2')
# pool2 (1, 24, 24, 24, 128)
# pool2_frac = fractal_net(
# is_global_path_list[1],
# global_path_list[1],
# local_path_list[1],
# self.Blocks,
# self.Columns)(pool2_in)
# pool2 = pool2_in + pool2_frac
pool2 = pool2_in
conv3_1 = conv3d(
input=pool2,
output_chn=256,
kernel_size=3,
stride=1,
use_bias=False,
name='conv3a')
# (1, 24, 24, 24, 256)
conv3_1_bn = tf.contrib.layers.batch_norm(
conv3_1,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=phase_flag,
scope="conv3_1_batch_norm")
conv3_1_relu = tf.nn.relu(conv3_1_bn, name='conv3_1_relu')
conv3_2 = conv3d(
input=conv3_1_relu,
output_chn=256,
kernel_size=3,
stride=1,
use_bias=False,
name='conv3b')
# (1, 24, 24, 24, 256)
conv3_2 = conv3_2 + conv3_1
conv3_2_bn = tf.contrib.layers.batch_norm(
conv3_2,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=phase_flag,
scope="conv3_2_batch_norm")
conv3_2_relu = tf.nn.relu(conv3_2_bn, name='conv3_2_relu')
pool3_in = tf.layers.max_pooling3d(
inputs=conv3_2_relu, pool_size=2, strides=2, name='pool3')
# pool3 (1, 12, 12, 12, 256)
# pool3_frac = fractal_net(
# is_global_path_list[2],
# global_path_list[2],
# local_path_list[2],
# self.Blocks,
# self.Columns)(pool3_in)
pool3 = pool3_in
# pool3 = pool3_in + pool3_frac
conv4_1 = conv3d(
input=pool3,
output_chn=512,
kernel_size=3,
stride=1,
use_bias=False,
name='conv4a')
# conv4_1 (1, 12, 12, 12, 512)
conv4_1_bn = tf.contrib.layers.batch_norm(
conv4_1,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=phase_flag,
scope="conv4_1_batch_norm")
conv4_1_relu = tf.nn.relu(conv4_1_bn, name='conv4_1_relu')
conv4_2 = conv3d(
input=conv4_1_relu,
output_chn=512,
kernel_size=3,
stride=1,
use_bias=False,
name='conv4b')
conv4_2 = conv4_2 + conv4_1
# conv4_2 (1, 12, 12, 12, 512)
conv4_2_bn = tf.contrib.layers.batch_norm(
conv4_2,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=phase_flag,
scope="conv4_2_batch_norm")
conv4_2_relu = tf.nn.relu(conv4_2_bn, name='conv4_2_relu')
pool4 = tf.layers.max_pooling3d(
inputs=conv4_2_relu,
pool_size=2,
strides=2,
name='pool4')
# pool4 (1, 6, 6, 6, 512)
conv5_1 = conv_bn_relu(
input=pool4,
output_chn=512,
kernel_size=3,
stride=1,
use_bias=False,
is_training=phase_flag,
name='conv5_1')
# conv5_1 (1, 6, 6, 6, 512)
conv5_2 = conv_bn_relu(
input=conv5_1,
output_chn=512,
kernel_size=3,
stride=1,
use_bias=False,
is_training=phase_flag,
name='conv5_2')
# conv5_2 (1, 6, 6, 6, 512)
deconv1_1 = deconv_bn_relu(
input=conv5_2,
output_chn=512,
is_training=phase_flag,
name='deconv1_1')
# (1, 12, 12, 12, 512)
concat_1 = tf.concat([deconv1_1, conv4_2],
axis=concat_dim, name='concat_1')
# (1, 12, 12, 12, 1024)
deconv1_2_in = conv_bn_relu(
input=concat_1,
output_chn=256,
kernel_size=3,
stride=1,
use_bias=False,
is_training=phase_flag,
name='deconv1_2')
# deconv1_2_frac = fractal_net(
# is_global_path_list[3],
# global_path_list[3],
# local_path_list[3],
# self.Blocks,
# self.Columns)(deconv1_2_in)
deconv1_2 = deconv1_2_in
# deconv1_2 = deconv1_2_in + deconv1_2_frac # (1, 12, 12, 12, 256)
deconv2_1 = deconv_bn_relu(
input=deconv1_2,
output_chn=256,
is_training=phase_flag,
name='deconv2_1')
concat_2 = tf.concat([deconv2_1, conv3_2],
axis=concat_dim, name='concat_2')
# deconv2_2 (1, 24, 24, 24, 512)
deconv2_2_in = conv_bn_relu(
input=concat_2,
output_chn=128,
kernel_size=3,
stride=1,
use_bias=False,
is_training=phase_flag,
name='deconv2_2')
# deconv2_2_frac = fractal_net(
# is_global_path_list[4],
# global_path_list[4],
# local_path_list[4],
# self.Blocks,
# self.Columns)(deconv2_2_in)
deconv2_2 = deconv2_2_in
# deconv2_2 = deconv2_2_in + deconv2_2_frac
# deconv2_2 (1, 24, 24, 24, 128)
deconv3_1 = deconv_bn_relu(
input=deconv2_2,
output_chn=128,
is_training=phase_flag,
name='deconv3_1')
# deconv3_1 (1, 48, 48, 48, 128)
concat_3 = tf.concat([deconv3_1, conv2_1],
axis=concat_dim, name='concat_3')
# deconv3_1 (1, 48, 48, 48, 256)
deconv3_2_in = conv_bn_relu(
input=concat_3,
output_chn=64,
kernel_size=3,
stride=1,
use_bias=False,
is_training=phase_flag,
name='deconv3_2')
# deconv3_2_frac = fractal_net(
# is_global_path_list[5],
# global_path_list[5],
# local_path_list[5],
# self.Blocks,
# self.Columns)(deconv3_2_in)
deconv3_2 = deconv3_2_in
# deconv3_2 = deconv3_2_in + deconv3_2_frac
# deconv3_2 (1, 48, 48, 48, 64)
deconv4_1 = deconv_bn_relu(
input=deconv3_2,
output_chn=64,
is_training=phase_flag,
name='deconv4_1')
# deconv4_2 (1, 96, 96, 96, 32)
concat_4 = tf.concat([deconv4_1, conv1_1],
axis=concat_dim, name='concat_4')
# deconv4_2 (1, 96, 96, 96, 64)
deconv4_2 = conv_bn_relu(
input=concat_4,
output_chn=32,
kernel_size=3,
stride=1,
use_bias=False,
is_training=phase_flag,
name='deconv4_2') # deconv4_2 (1, 96, 96, 96, 32)
pre_pro = conv3d(
input=deconv4_2,
output_chn=output_channel,
kernel_size=1,
stride=1,
use_bias=True,
name='pre_pro')
# pred_frac = fractal_net(is_global_path_list[3],global_path_list[3],local_path_list[3],self.Blocks,self.Columns)(pre_pro)
pred_prob = pre_pro # pred_prob (1, 96, 96, 96, 8) Here get the prediction
# ======================For predicition=============================
# auxiliary prediction 0
aux0_conv = conv3d(
input=deconv1_2,
output_chn=output_channel,
kernel_size=1,
stride=1,
use_bias=True,
name='aux0_conv') # aux0_conv (1, 12, 12, 12, 8) 8 class output
aux0_deconv_1 = Deconv3d(
input=aux0_conv,
output_chn=output_channel,
name='aux0_deconv_1') # aux0_deconv_1 (1, 24, 24, 24, 8)
aux0_deconv_2 = Deconv3d(
input=aux0_deconv_1,
output_chn=output_channel,
name='aux0_deconv_2') # aux0_deconv_2 (1, 48, 48, 48, 8)
aux0_prob = Deconv3d(
input=aux0_deconv_2,
output_chn=output_channel,
name='aux0_prob') # aux0_prob (1, 96, 96, 96, 8)
# auxiliary prediction 1
aux1_conv = conv3d(
input=deconv2_2,
output_chn=output_channel,
kernel_size=1,
stride=1,
use_bias=True,
name='aux1_conv') # aux1_conv (1, 24, 24, 24, 8)
aux1_deconv_1 = Deconv3d(
input=aux1_conv,
output_chn=output_channel,
name='aux1_deconv_1') # aux1_deconv_1 (1, 48, 48, 48, 8)
aux1_prob = Deconv3d(
input=aux1_deconv_1,
output_chn=output_channel,
name='aux1_prob') # aux1_prob (1, 96, 96, 96, 8)
# auxiliary prediction 2
aux2_conv = conv3d(
input=deconv3_2,
output_chn=output_channel,
kernel_size=1,
stride=1,
use_bias=True,
name='aux2_conv') # aux2_conv (1, 48, 48, 48, 8)
aux2_prob = Deconv3d(
input=aux2_conv,
output_chn=output_channel,
name='aux2_prob') # aux2_prob (1, 96, 96, 96, 8)
soft_prob = tf.nn.softmax(pred_prob, name='pred_soft')
pred_label = tf.argmax(soft_prob, axis=4, name='argmax')
return pred_prob, pred_label, aux0_prob, aux1_prob, aux2_prob
def unet_resnet(input_pred, input_img, output_channel, stage):
input_shape = input_img.shape
input_channel = input_shape.dims[-1].value
input_pred_softmax = tf.nn.softmax(input_pred, name='softmax_ss' + stage)
forground_input_pred = tf.expand_dims(input_pred_softmax[:, :, :, :, 1], axis=-1)
input_concat = tf.concat([forground_input_pred, input_img], axis=-1) # (1, 96, 96, 96, 2)
input_attention = forground_input_pred * input_img # (1, 96, 96, 96, input_channel)
# conv block1
conv_bn_1_1 = conv_bn_relu(input=input_attention, output_chn=16, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block1_conv1')
input_cat = tf.concat([input_attention, input_attention, input_attention, input_attention,
input_attention, input_attention, input_attention, input_attention], axis=-1)
# diffirence for odd input or even input
if input_channel % 2 == 0 or input_channel == 1:
input_tile = tf.tile(input=input_attention, multiples=[1, 1, 1, 1, int(16/input_channel)], name='tile' + stage)
else:
input_tile = tf.tile(input=input_attention, multiples=[1, 1, 1, 1, int(16/(input_channel-1))], name='tile' + stage)
input_tile = input_tile[:,:,:,:,0:16]
conv_bn_skip_1_1 = input_tile + conv_bn_1_1
pool1_1 = tf.layers.max_pooling3d(inputs=conv_bn_skip_1_1, pool_size=2, strides=2, name=stage + 'pool_1_1')
# conv block2
conv_bn_2_1 = conv_bn_relu(input=pool1_1, output_chn=32, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block2_conv1')
conv_bn_2_2 = conv_bn_relu(input=conv_bn_2_1, output_chn=32, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block2_conv2')
pool1_1_cat = tf.concat([pool1_1, pool1_1], axis=-1)
conv_bn_skip_2_1 = pool1_1_cat + conv_bn_2_2
pool_2_1 = tf.layers.max_pooling3d(inputs=conv_bn_skip_2_1, pool_size=2, strides=2, name=stage + 'pool2_2')
# conv block3
conv_bn_3_1 = conv_bn_relu(input=pool_2_1, output_chn=64, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block3_conv1')
conv_bn_3_2 = conv_bn_relu(input=conv_bn_3_1, output_chn=64, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block3_conv2')
conv_bn_3_3 = conv_bn_relu(input=conv_bn_3_2, output_chn=64, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block3_conv3')
pool_2_1_cat = tf.concat([pool_2_1, pool_2_1], axis=-1)
conv_bn_skip_3_1 = conv_bn_3_3 + pool_2_1_cat
pool3_1 = tf.layers.max_pooling3d(inputs=conv_bn_skip_3_1, pool_size=2, strides=2, name=stage + 'pool3_1')
# conv block4
conv_bn_4_1 = conv_bn_relu(input=pool3_1, output_chn=128, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block4_conv1')
conv_bn_4_2 = conv_bn_relu(input=conv_bn_4_1, output_chn=128, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block4_conv2')
conv_bn_4_3 = conv_bn_relu(input=conv_bn_4_2, output_chn=128, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block4_conv3')
pool3_1_cat = tf.concat([pool3_1, pool3_1], axis=-1)
conv_bn_skip_4_1 = conv_bn_4_3 + pool3_1_cat
pool4_1 = tf.layers.max_pooling3d(inputs=conv_bn_skip_4_1, pool_size=2, strides=2, name=stage + 'pool4_1')
# conv block5
conv_bn_5_1 = conv_bn_relu(input=pool4_1, output_chn=256, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block5_conv1')
conv_bn_5_2 = conv_bn_relu(input=conv_bn_5_1, output_chn=256, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block5_conv2')
conv_bn_5_3 = conv_bn_relu(input=conv_bn_5_2, output_chn=256, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block5_conv3')
pool4_1_cat = tf.concat([pool4_1, pool4_1], axis=-1)
conv_bn_skip_5_1 = conv_bn_5_3 + pool4_1_cat
# upsampling conv block6
deconv_bn_1_1 = deconv_bn_relu(input=conv_bn_skip_5_1, output_chn=128, is_training=True,
name=stage + 'deconv_1_1')
concat1 = tf.concat([deconv_bn_1_1, conv_bn_skip_4_1], axis=-1, name=stage + 'concat1')
conv_bn_6_1 = conv_bn_relu(input=concat1, output_chn=256, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block6_conv1')
conv_bn_6_2 = conv_bn_relu(input=conv_bn_6_1, output_chn=256, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block6_conv2')
conv_bn_6_3 = conv_bn_relu(input=conv_bn_6_2, output_chn=256, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'blovk6_conv3')
deconv_bn_1_1_cat = tf.concat([deconv_bn_1_1, deconv_bn_1_1], axis=-1)
conv_bn_skip_6_1 = conv_bn_6_3 + deconv_bn_1_1_cat
# conv block7
deconv_bn_2_1 = deconv_bn_relu(input=conv_bn_skip_6_1, output_chn=64, is_training=True,
name=stage + 'deconv_2_1')
concat2 = tf.concat([deconv_bn_2_1, conv_bn_skip_3_1], axis=-1, name=stage + 'concat2')
conv_bn_7_1 = conv_bn_relu(input=concat2, output_chn=128, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block7_conv1')
conv_bn_7_2 = conv_bn_relu(input=conv_bn_7_1, output_chn=128, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block7_conv2')
conv_bn_7_3 = conv_bn_relu(input=conv_bn_7_2, output_chn=128, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block7_conv3')
deconv_bn_2_1_cat = tf.concat([deconv_bn_2_1, deconv_bn_2_1], axis=-1)
conv_bn_skip_7_1 = conv_bn_7_3 + deconv_bn_2_1_cat
# conv block8
deconv_bn_3_1 = deconv_bn_relu(input=conv_bn_skip_7_1, output_chn=32, is_training=True,
name=stage + 'deconv_3_1')
concat3 = tf.concat([deconv_bn_3_1, conv_bn_skip_2_1], axis=-1, name=stage + 'concat3')
conv_bn_8_1 = conv_bn_relu(input=concat3, output_chn=64, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block8_conv1')
conv_bn_8_2 = conv_bn_relu(input=conv_bn_8_1, output_chn=64, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block8_conv2')
deconv_bn_3_1_cat = tf.concat([deconv_bn_3_1, deconv_bn_3_1], axis=-1)
conv_bn_skip_8_1 = conv_bn_8_2 + deconv_bn_3_1_cat
# conv block9
deconv_bn_4_1 = deconv_bn_relu(input=conv_bn_skip_8_1, output_chn=16, is_training=True,
name=stage + 'deconv_4_1')
concat4 = tf.concat([deconv_bn_4_1, conv_bn_skip_1_1], axis=-1, name=stage + 'conca4_1')
conv_bn_9_1 = conv_bn_relu(input=concat4, output_chn=32, kernel_size=3, stride=1, use_bias=False,
is_training=True, name=stage + 'block9_conv1')
deconv_bn_4_1_cat = tf.concat([deconv_bn_4_1, deconv_bn_4_1], axis=-1)
conv_bn_skip_9_1 = conv_bn_9_1 + deconv_bn_4_1_cat
# prediction layer
pred = conv3d(input=conv_bn_skip_9_1, output_chn=output_channel, kernel_size=1, stride=1, use_bias=True,
name=stage + 'pred')
soft_prob_v = tf.nn.softmax(pred, name='pred_soft_v')
pred_label_v = tf.argmax(soft_prob_v, axis=4, name='argmax_v')
return pred, pred_label_v
def conv3d(
input,
output_chn,
kernel_size,
stride,
use_bias=False,
name='conv'):
return tf.layers.conv3d(
inputs=input,
filters=output_chn,
kernel_size=kernel_size,
strides=stride,
padding='same',
data_format='channels_last',
kernel_initializer=tf.truncated_normal_initializer(
0.0,
0.01),
kernel_regularizer=slim.l2_regularizer(0.0005),
use_bias=use_bias,
name=name)
def conv_bn_relu(
input,
output_chn,
kernel_size,
stride,
use_bias,
is_training,
name):
with tf.variable_scope(name):
conv = conv3d(
input,
output_chn,
kernel_size,
stride,
use_bias,
name='conv')
bn = tf.contrib.layers.batch_norm(
conv,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=is_training,
scope="batch_norm")
relu = tf.nn.relu(bn, name='relu')
return relu
# deconvolution
def Deconv3d(input, output_chn, name):
batch, in_depth, in_height, in_width, in_channels = [
int(d) for d in input.get_shape()]
filter = tf.get_variable(
name + "/filter",
shape=[
4,
4,
4,
output_chn,
in_channels],
dtype=tf.float32,
initializer=tf.random_normal_initializer(
0,
0.01),
regularizer=slim.l2_regularizer(0.0005))
conv = tf.nn.conv3d_transpose(
value=input,
filter=filter,
output_shape=[
batch,
in_depth * 2,
in_height * 2,
in_width * 2,
output_chn],
strides=[
1,
2,
2,
2,
1],
padding="SAME",
name=name)
return conv
def Unsample(input, output_chn, name):
batch, in_depth, in_height, in_width, in_channels = [
int(d) for d in input.get_shape()]
base = input.shape[-2]
data = 96 / int(base)
print("base shape", data)
filter = tf.get_variable(
name + "/filter",
shape=[
4,
4,
4,
output_chn,
in_channels],
dtype=tf.float32,
initializer=tf.random_normal_initializer(
0,
0.01),
regularizer=slim.l2_regularizer(0.0005))
conv = tf.nn.conv3d_transpose(
value=input, filter=filter, output_shape=[
batch, 96, 96, 96, output_chn], strides=[
1, data, data, data, 1], padding="SAME", name=name)
return conv
def deconv_bn_relu(input, output_chn, is_training, name):
with tf.variable_scope(name):
conv = Deconv3d(input, output_chn, name='deconv')
# with tf.device("/cpu:0"):
bn = tf.contrib.layers.batch_norm(
conv,
decay=0.9,
updates_collections=None,
epsilon=1e-5,
scale=True,
is_training=is_training,
scope="batch_norm")
relu = tf.nn.relu(bn, name='relu')
return relu
def conv_bn_relu_x3(
input,
output_chn,
kernel_size,
stride,
use_bias,
is_training,
name):
with tf.variable_scope(name):
z = conv_bn_relu(
input,
output_chn,
kernel_size,
stride,
use_bias,
is_training,
"dense1")
z_out = conv_bn_relu(
z,
output_chn,
kernel_size,
stride,
use_bias,
is_training,
"dense2")
z_out = conv_bn_relu(
z_out,
output_chn,
kernel_size,
stride,
use_bias,
is_training,
"dense3")
return z + z_out | 34.819182 | 126 | 0.597065 | [
"MIT"
] | JohnleeHIT/Brats2019 | src/models.py | 22,145 | Python |
#!/usr/bin/env python2
# -*- encoding: utf-8 -*-
import pygame
import sys
import numpy as np
CONST_LOCK_FILE = "lock.txt"
#CONST_GRAPH_FILE = "../tsptours/graph.tsp"
CONST_GRAPH_FILE = "graph.tsp"
CONST_STOP = "STOP"
CONST_CUSTOM_FILE = None
def main():
pygame.init()
screen = pygame.display.set_mode((700,700))
screen.fill((255,255,255))
pygame.display.set_caption("Ant Colony TSP Solver - press ENTER to solve")
graph = []
tour = []
cost = g = 0
state = 0
pygame.display.flip()
while (True):
for event in pygame.event.get():
if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
print "El usuario ha decidido cerrar la aplicación."
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN and state == 0 and CONST_CUSTOM_FILE:
#print "Agregando la posición del click", pygame.mouse.get_pos()
data = np.loadtxt(CONST_CUSTOM_FILE, dtype=int, delimiter=',')
for line in data:
line = (line[0]*7, line[1]*7)
graph.append(line)
pygame.draw.circle(screen, (0,0,0), line, 5, 0)
pygame.display.flip()
from_file = False
elif event.type == pygame.MOUSEBUTTONDOWN and state == 0:
#print "Agregando la posición del click", pygame.mouse.get_pos()
graph.append(pygame.mouse.get_pos())
pygame.draw.circle(screen, (0,0,0), pygame.mouse.get_pos(), 5, 0)
pygame.display.flip()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN:
lock_file = open(CONST_LOCK_FILE, "w")
lock_file.write("0");
lock_file.close()
graph_file = open(CONST_GRAPH_FILE, "w")
graph_file.write("NAME : %s\n" % CONST_GRAPH_FILE)
graph_file.write("COMMENT : %s-city problem\n" % str(len(graph)))
graph_file.write("TYPE : TSP\n")
graph_file.write("DIMENSION : %s\n" % str(len(graph)))
graph_file.write("EDGE_WEIGHT_TYPE : EUC_2D\n")
graph_file.write("NODE_COORD_SECTION\n")
for x in range(0, len(graph)):
#print "%d %d %d" % (x, graph[x][0], graph[x][1])
graph_file.write("%d %d %d" % (x, graph[x][0], graph[x][1]))
graph_file.write("\n")
graph_file.write("EOF")
graph_file.close()
lock_file = open("lock.txt", "w")
lock_file.write("1");
lock_file.close()
# Primera salida.
tour = input() # [0, .., n-1, n]
cost = input() # Costo del recorrido
g = input() # Cantidad de iteraciones
lock_file = open("lock.txt", "w")
lock_file.write("0");
lock_file.close()
state = 1
if state == 1:
if tour != CONST_STOP:
pygame.display.set_caption("Ant Colony TSP Solver - current length: " + str(cost) + " | iterations: " + str(g) + " (SOLVING...)")
screen.fill((255,255,255))
# Vuelve a dibujar los círculos
for i in graph:
pygame.draw.circle(screen, (255,0,0), i, 5, 0)
for i in range(0, len(tour)):
pygame.draw.line(screen, (255, 0, 0), graph[tour[i]], graph[tour[(i + 1) % len(tour)]])
pygame.display.flip()
# Salidas siguientes
tour = input()
if tour != CONST_STOP:
cost = input()
g = input()
else:
pygame.display.set_caption("Ant Colony TSP Solver - current length: " + str(cost) + " | iterations: " + str(g) + " (FINISHED)")
finished = True
state = 2
if __name__ == '__main__':
if len(sys.argv) == 2:
CONST_CUSTOM_FILE = sys.argv[1]
main() | 39.923077 | 145 | 0.509152 | [
"MIT"
] | mattaereal/AntColonyOptimization | graphic/tsp_matt.py | 4,156 | Python |
def extractReMonsterWiki(item):
"""
Parser for 'Re:Monster Wiki'
"""
vol, chp, frag, postfix = extractVolChapterFragmentPostfix(item['title'])
if not (chp or vol) or 'preview' in item['title'].lower():
return None
if 'WATTT' in item['tags']:
return buildReleaseMessageWithType(item, 'WATTT', vol, chp, frag=frag, postfix=postfix)
return False
| 32.181818 | 89 | 0.714689 | [
"BSD-3-Clause"
] | fake-name/ReadableWebProxy | WebMirror/management/rss_parser_funcs/feed_parse_extractReMonsterWiki.py | 354 | Python |
#!/usr/bin/python
# coding: utf-8 -*-
# (c) 2017, Wayne Witzel III <[email protected]>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = '''
---
module: tower_job_template
author: "Wayne Witzel III (@wwitzel3)"
version_added: "2.3"
short_description: create, update, or destroy Ansible Tower job template.
description:
- Create, update, or destroy Ansible Tower job templates. See
U(https://www.ansible.com/tower) for an overview.
options:
name:
description:
- Name to use for the job template.
required: True
type: str
description:
description:
- Description to use for the job template.
type: str
job_type:
description:
- The job type to use for the job template.
required: False
choices: ["run", "check"]
type: str
inventory:
description:
- Name of the inventory to use for the job template.
type: str
project:
description:
- Name of the project to use for the job template.
required: True
type: str
playbook:
description:
- Path to the playbook to use for the job template within the project provided.
required: True
type: str
credential:
description:
- Name of the credential to use for the job template.
- Deprecated, mutually exclusive with 'credentials'.
version_added: 2.7
type: str
credentials:
description:
- List of credentials to use for the job template.
- Will not remove any existing credentials. This may change in the future.
version_added: 2.8
type: list
default: []
vault_credential:
description:
- Name of the vault credential to use for the job template.
- Deprecated, mutually exclusive with 'credential'.
version_added: 2.7
type: str
forks:
description:
- The number of parallel or simultaneous processes to use while executing the playbook.
type: int
limit:
description:
- A host pattern to further constrain the list of hosts managed or affected by the playbook
type: str
verbosity:
description:
- Control the output level Ansible produces as the playbook runs. 0 - Normal, 1 - Verbose, 2 - More Verbose, 3 - Debug, 4 - Connection Debug.
choices: [0, 1, 2, 3, 4]
default: 0
type: int
extra_vars:
description:
- Specify C(extra_vars) for the template.
type: dict
version_added: 3.7
extra_vars_path:
description:
- This parameter has been deprecated, please use 'extra_vars' instead.
- Path to the C(extra_vars) YAML file.
type: path
job_tags:
description:
- Comma separated list of the tags to use for the job template.
type: str
force_handlers_enabled:
description:
- Enable forcing playbook handlers to run even if a task fails.
version_added: 2.7
type: bool
default: 'no'
skip_tags:
description:
- Comma separated list of the tags to skip for the job template.
type: str
start_at_task:
description:
- Start the playbook at the task matching this name.
version_added: 2.7
type: str
diff_mode_enabled:
description:
- Enable diff mode for the job template.
version_added: 2.7
type: bool
default: 'no'
fact_caching_enabled:
description:
- Enable use of fact caching for the job template.
version_added: 2.7
type: bool
default: 'no'
host_config_key:
description:
- Allow provisioning callbacks using this host config key.
type: str
ask_diff_mode:
description:
- Prompt user to enable diff mode (show changes) to files when supported by modules.
version_added: 2.7
type: bool
default: 'no'
ask_extra_vars:
description:
- Prompt user for (extra_vars) on launch.
type: bool
default: 'no'
ask_limit:
description:
- Prompt user for a limit on launch.
version_added: 2.7
type: bool
default: 'no'
ask_tags:
description:
- Prompt user for job tags on launch.
type: bool
default: 'no'
ask_skip_tags:
description:
- Prompt user for job tags to skip on launch.
version_added: 2.7
type: bool
default: 'no'
ask_job_type:
description:
- Prompt user for job type on launch.
type: bool
default: 'no'
ask_verbosity:
description:
- Prompt user to choose a verbosity level on launch.
version_added: 2.7
type: bool
default: 'no'
ask_inventory:
description:
- Prompt user for inventory on launch.
type: bool
default: 'no'
ask_credential:
description:
- Prompt user for credential on launch.
type: bool
default: 'no'
survey_enabled:
description:
- Enable a survey on the job template.
version_added: 2.7
type: bool
default: 'no'
survey_spec:
description:
- JSON/YAML dict formatted survey definition.
version_added: 2.8
type: dict
required: False
become_enabled:
description:
- Activate privilege escalation.
type: bool
default: 'no'
concurrent_jobs_enabled:
description:
- Allow simultaneous runs of the job template.
version_added: 2.7
type: bool
default: 'no'
timeout:
description:
- Maximum time in seconds to wait for a job to finish (server-side).
type: int
custom_virtualenv:
version_added: "2.9"
description:
- Local absolute file path containing a custom Python virtualenv to use.
type: str
required: False
default: ''
state:
description:
- Desired state of the resource.
default: "present"
choices: ["present", "absent"]
type: str
extends_documentation_fragment: awx.awx.auth
notes:
- JSON for survey_spec can be found in Tower API Documentation. See
U(https://docs.ansible.com/ansible-tower/latest/html/towerapi/api_ref.html#/Job_Templates/Job_Templates_job_templates_survey_spec_create)
for POST operation payload example.
'''
EXAMPLES = '''
- name: Create tower Ping job template
tower_job_template:
name: "Ping"
job_type: "run"
inventory: "Local"
project: "Demo"
playbook: "ping.yml"
credential: "Local"
state: "present"
tower_config_file: "~/tower_cli.cfg"
survey_enabled: yes
survey_spec: "{{ lookup('file', 'my_survey.json') }}"
custom_virtualenv: "/var/lib/awx/venv/custom-venv/"
'''
from ..module_utils.ansible_tower import TowerModule, tower_auth_config, tower_check_mode
import json
try:
import tower_cli
import tower_cli.exceptions as exc
from tower_cli.conf import settings
except ImportError:
pass
def update_fields(module, p):
'''This updates the module field names
to match the field names tower-cli expects to make
calling of the modify/delete methods easier.
'''
params = p.copy()
field_map = {
'fact_caching_enabled': 'use_fact_cache',
'ask_diff_mode': 'ask_diff_mode_on_launch',
'ask_extra_vars': 'ask_variables_on_launch',
'ask_limit': 'ask_limit_on_launch',
'ask_tags': 'ask_tags_on_launch',
'ask_skip_tags': 'ask_skip_tags_on_launch',
'ask_verbosity': 'ask_verbosity_on_launch',
'ask_inventory': 'ask_inventory_on_launch',
'ask_credential': 'ask_credential_on_launch',
'ask_job_type': 'ask_job_type_on_launch',
'diff_mode_enabled': 'diff_mode',
'concurrent_jobs_enabled': 'allow_simultaneous',
'force_handlers_enabled': 'force_handlers',
}
params_update = {}
for old_k, new_k in field_map.items():
v = params.pop(old_k)
params_update[new_k] = v
extra_vars = params.get('extra_vars')
extra_vars_path = params.get('extra_vars_path')
if extra_vars:
params_update['extra_vars'] = [json.dumps(extra_vars)]
elif extra_vars_path is not None:
params_update['extra_vars'] = ['@' + extra_vars_path]
module.deprecate(
msg='extra_vars_path should not be used anymore. Use \'extra_vars: "{{ lookup(\'file\', \'/path/to/file\') | from_yaml }}"\' instead',
version="3.8"
)
params.update(params_update)
return params
def update_resources(module, p):
params = p.copy()
identity_map = {
'project': 'name',
'inventory': 'name',
'credential': 'name',
'vault_credential': 'name',
}
for k, v in identity_map.items():
try:
if params[k]:
key = 'credential' if '_credential' in k else k
result = tower_cli.get_resource(key).get(**{v: params[k]})
params[k] = result['id']
elif k in params:
# unset empty parameters to avoid ValueError: invalid literal for int() with base 10: ''
del(params[k])
except (exc.NotFound) as excinfo:
module.fail_json(msg='Failed to update job template: {0}'.format(excinfo), changed=False)
return params
def main():
argument_spec = dict(
name=dict(required=True),
description=dict(default=''),
job_type=dict(choices=['run', 'check']),
inventory=dict(default=''),
project=dict(required=True),
playbook=dict(required=True),
credential=dict(default=''),
vault_credential=dict(default=''),
custom_virtualenv=dict(type='str', required=False),
credentials=dict(type='list', default=[]),
forks=dict(type='int'),
limit=dict(default=''),
verbosity=dict(type='int', choices=[0, 1, 2, 3, 4], default=0),
extra_vars=dict(type='dict', required=False),
extra_vars_path=dict(type='path', required=False),
job_tags=dict(default=''),
force_handlers_enabled=dict(type='bool', default=False),
skip_tags=dict(default=''),
start_at_task=dict(default=''),
timeout=dict(type='int', default=0),
fact_caching_enabled=dict(type='bool', default=False),
host_config_key=dict(default=''),
ask_diff_mode=dict(type='bool', default=False),
ask_extra_vars=dict(type='bool', default=False),
ask_limit=dict(type='bool', default=False),
ask_tags=dict(type='bool', default=False),
ask_skip_tags=dict(type='bool', default=False),
ask_job_type=dict(type='bool', default=False),
ask_verbosity=dict(type='bool', default=False),
ask_inventory=dict(type='bool', default=False),
ask_credential=dict(type='bool', default=False),
survey_enabled=dict(type='bool', default=False),
survey_spec=dict(type='dict', required=False),
become_enabled=dict(type='bool', default=False),
diff_mode_enabled=dict(type='bool', default=False),
concurrent_jobs_enabled=dict(type='bool', default=False),
state=dict(choices=['present', 'absent'], default='present'),
)
module = TowerModule(
argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[
('credential', 'credentials'),
('vault_credential', 'credentials'),
('extra_vars_path', 'extra_vars'),
]
)
name = module.params.get('name')
state = module.params.pop('state')
json_output = {'job_template': name, 'state': state}
tower_auth = tower_auth_config(module)
with settings.runtime_values(**tower_auth):
tower_check_mode(module)
jt = tower_cli.get_resource('job_template')
params = update_resources(module, module.params)
params = update_fields(module, params)
params['create_on_missing'] = True
try:
if state == 'present':
result = jt.modify(**params)
json_output['id'] = result['id']
elif state == 'absent':
result = jt.delete(**params)
except (exc.ConnectionError, exc.BadRequest, exc.NotFound, exc.AuthError) as excinfo:
module.fail_json(msg='Failed to update job template: {0}'.format(excinfo), changed=False)
cred_list = module.params.get('credentials')
if cred_list:
cred = tower_cli.get_resource('credential')
for cred_name in cred_list:
try:
cred_id = cred.get(name=cred_name)['id']
r = jt.associate_credential(result['id'], cred_id)
except (exc.ConnectionError, exc.BadRequest, exc.NotFound, exc.AuthError) as excinfo:
module.fail_json(msg='Failed to add credential to job template: {0}'.format(excinfo), changed=False)
if r.get('changed'):
result['changed'] = True
json_output['changed'] = result['changed']
module.exit_json(**json_output)
if __name__ == '__main__':
main()
| 32.348558 | 149 | 0.623021 | [
"Apache-2.0"
] | activelan/awx | awx_collection/plugins/modules/tower_job_template.py | 13,457 | Python |
from django.db import models
from django.conf import settings
from django.contrib.auth.models import User
from django.db.models.signals import post_save
# Create your models here.
class Profile(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL)
date_of_birth = models.DateField(blank=True, null=True)
photo = models.ImageField(upload_to='users/%Y/%m/%d', blank=True)
course_bookmark = models.CharField(max_length=100, default='the-strategy')
module_bookmark = models.PositiveIntegerField(default=0)
def __str__(self):
return 'Profile for user {}'.format(self.user.username)
class Contact(models.Model):
user_from = models.ForeignKey(User, related_name='rel_from_set')
user_to = models.ForeignKey(User, related_name='rel_to_set')
created = models.DateTimeField(auto_now_add=True, db_index=True)
class Meta:
ordering = ('-created',)
def __str__(self):
return '{} follows {}'.format(self.user_from, self.user_to)
User.add_to_class('following', models.ManyToManyField('self',
through=Contact,
related_name='followers',
symmetrical=False))
# Signal to auto-create a profile when a User is created.
def create_user_profile(sender, instance, created, **kwargs):
if created:
Profile.objects.create(user=instance)
post_save.connect(create_user_profile, sender=User)
| 30.311111 | 75 | 0.744868 | [
"MIT"
] | pauljherrera/avantiweb | account/models.py | 1,364 | Python |
# -*- coding: utf-8 -*-
from irc3.plugins.command import command
@command
def echo(bot, mask, target, args):
"""Echo command
%%echo <words>...
"""
yield ' '.join(args['<words>'])
@command(permission='admin', public=False)
def adduser(bot, mask, target, args):
"""Add a user
%%adduser <name> <password>
"""
bot.privmsg(mask.nick, 'User added')
@command(show_in_help_list=False)
def my_secret_operation(bot, mask, target, args):
"""Do something you don't want in !help all the time
%%my_secret_operation
"""
yield "I like turtles"
| 19.933333 | 56 | 0.618729 | [
"MIT"
] | gawel/irc3 | examples/mycommands.py | 598 | Python |
###########################################################################
#
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
###########################################################################
from starthinker.util.project import project
from starthinker.util.salesforce import get_service
if __name__ == '__main__':
project.from_commandline('setup')
service = get_service()
print('Credentials Ready: %s' % project.recipe['setup']['auth']['salesforce'])
| 38.846154 | 80 | 0.635644 | [
"Apache-2.0"
] | quan/starthinker | starthinker/util/salesforce/quickstart.py | 1,010 | Python |
# Copyright (c) 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import os
from metrics import power
from telemetry import test
from telemetry.core import util
from telemetry.page import page_measurement
from telemetry.page import page_set
class _DromaeoMeasurement(page_measurement.PageMeasurement):
def __init__(self):
super(_DromaeoMeasurement, self).__init__()
self._power_metric = power.PowerMetric()
def CustomizeBrowserOptions(self, options):
power.PowerMetric.CustomizeBrowserOptions(options)
def DidNavigateToPage(self, page, tab):
self._power_metric.Start(page, tab)
def MeasurePage(self, page, tab, results):
tab.WaitForJavaScriptExpression(
'window.document.cookie.indexOf("__done=1") >= 0', 600)
self._power_metric.Stop(page, tab)
self._power_metric.AddResults(tab, results)
js_get_results = 'JSON.stringify(window.automation.GetResults())'
print js_get_results
score = eval(tab.EvaluateJavaScript(js_get_results))
def Escape(k):
chars = [' ', '-', '/', '(', ')', '*']
for c in chars:
k = k.replace(c, '_')
return k
suffix = page.url[page.url.index('?') + 1 : page.url.index('&')]
for k, v in score.iteritems():
data_type = 'unimportant'
if k == suffix:
data_type = 'default'
results.Add(Escape(k), 'runs/s', float(v), data_type=data_type)
class _DromaeoBenchmark(test.Test):
"""A base class for Dromaeo benchmarks."""
test = _DromaeoMeasurement
def CreatePageSet(self, options):
"""Makes a PageSet for Dromaeo benchmarks."""
# Subclasses are expected to define a class member called query_param.
if not hasattr(self, 'query_param'):
raise NotImplementedError('query_param not in Dromaeo benchmark.')
url = 'file://index.html?%s&automated' % self.query_param
# The docstring of benchmark classes may also be used as a description
# when 'run_benchmarks list' is run.
description = self.__doc__ or 'Dromaeo JavaScript Benchmark'
page_set_dict = {
'description': description,
'pages': [{'url': url}],
}
dromaeo_dir = os.path.join(util.GetChromiumSrcDir(),
'chrome', 'test', 'data', 'dromaeo')
return page_set.PageSet.FromDict(page_set_dict, dromaeo_dir)
class DromaeoDomCoreAttr(_DromaeoBenchmark):
"""Dromaeo DOMCore attr JavaScript benchmark."""
tag = 'domcoreattr'
query_param = 'dom-attr'
class DromaeoDomCoreModify(_DromaeoBenchmark):
"""Dromaeo DOMCore modify JavaScript benchmark."""
tag = 'domcoremodify'
query_param = 'dom-modify'
class DromaeoDomCoreQuery(_DromaeoBenchmark):
"""Dromaeo DOMCore query JavaScript benchmark."""
tag = 'domcorequery'
query_param = 'dom-query'
class DromaeoDomCoreTraverse(_DromaeoBenchmark):
"""Dromaeo DOMCore traverse JavaScript benchmark."""
tag = 'domcoretraverse'
query_param = 'dom-traverse'
class DromaeoJslibAttrJquery(_DromaeoBenchmark):
"""Dromaeo JSLib attr jquery JavaScript benchmark"""
tag = 'jslibattrjquery'
query_param = 'jslib-attr-jquery'
class DromaeoJslibAttrPrototype(_DromaeoBenchmark):
"""Dromaeo JSLib attr prototype JavaScript benchmark"""
tag = 'jslibattrprototype'
query_param = 'jslib-attr-prototype'
class DromaeoJslibEventJquery(_DromaeoBenchmark):
"""Dromaeo JSLib event jquery JavaScript benchmark"""
tag = 'jslibeventjquery'
query_param = 'jslib-event-jquery'
class DromaeoJslibEventPrototype(_DromaeoBenchmark):
"""Dromaeo JSLib event prototype JavaScript benchmark"""
tag = 'jslibeventprototype'
query_param = 'jslib-event-prototype'
class DromaeoJslibModifyJquery(_DromaeoBenchmark):
"""Dromaeo JSLib modify jquery JavaScript benchmark"""
tag = 'jslibmodifyjquery'
query_param = 'jslib-modify-jquery'
class DromaeoJslibModifyPrototype(_DromaeoBenchmark):
"""Dromaeo JSLib modify prototype JavaScript benchmark"""
tag = 'jslibmodifyprototype'
query_param = 'jslib-modify-prototype'
class DromaeoJslibStyleJquery(_DromaeoBenchmark):
"""Dromaeo JSLib style jquery JavaScript benchmark"""
tag = 'jslibstylejquery'
query_param = 'jslib-style-jquery'
class DromaeoJslibStylePrototype(_DromaeoBenchmark):
"""Dromaeo JSLib style prototype JavaScript benchmark"""
tag = 'jslibstyleprototype'
query_param = 'jslib-style-prototype'
class DromaeoJslibTraverseJquery(_DromaeoBenchmark):
"""Dromaeo JSLib traverse jquery JavaScript benchmark"""
tag = 'jslibtraversejquery'
query_param = 'jslib-traverse-jquery'
class DromaeoJslibTraversePrototype(_DromaeoBenchmark):
"""Dromaeo JSLib traverse prototype JavaScript benchmark"""
tag = 'jslibtraverseprototype'
query_param = 'jslib-traverse-prototype'
| 31.122581 | 74 | 0.732172 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | Acidburn0zzz/chromium-1 | tools/perf/benchmarks/dromaeo.py | 4,824 | Python |
# ------------------------------------------------------------------------------------------------------
# Copyright (c) Leo Hanisch. All rights reserved.
# Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.
# ------------------------------------------------------------------------------------------------------
# pylint: disable=too-many-instance-attributes
from copy import deepcopy
import logging
import numpy as np
from .nest import Nest
from ..util import levy_flight as cuckoo
from .visualizer import Visualizer
LOGGER = logging.getLogger(__name__)
class CuckooProblem:
def __init__(self, **kwargs):
"""
Initialize a new cuckoo search problem.
"""
self.__upper_boundary = kwargs.get('upper_boundary', 4.)
self.__lower_boundary = kwargs.get('lower_boundary', 0.)
self.__alpha = kwargs.pop('alpha', 1)
self.__max_generations = kwargs.pop('max_generations', 10)
self.__lambda = kwargs.pop('lambda', 1.5)
self.__p_a = kwargs.pop('p_a', .1)
self.__function = kwargs['function']
self.__nests = [
Nest(lower_boundary=self.__lower_boundary, upper_boundary=self.__upper_boundary, function=self.__function)
for _ in range(kwargs['nests'])
]
# Initialize visualizer for plotting
kwargs['iteration_number'] = self.__max_generations
self.__visualizer = Visualizer(**kwargs)
def solve(self) -> Nest:
nest_indices = np.array(range(len(self.__nests)))
best_nest = deepcopy(min(self.__nests, key=lambda nest: nest.value))
positions, abandoned = zip(*[(nest.position, nest.abandoned) for nest in self.__nests])
self.__visualizer.add_data(positions=positions, best_position=best_nest.position, abandoned=abandoned)
LOGGER.info('Iteration 0 best solution="%s" at position="%s"', best_nest.value, best_nest.position)
for iteration in range(self.__max_generations):
# Perform levy flights to get cuckoo's new position
new_cuckoo_pos = [
np.clip(cuckoo.levy_flight(nest.position, self.__alpha, self.__lambda), a_min=self.__lower_boundary, a_max=self.__upper_boundary)
for nest in self.__nests
]
# Randomly select nests to be updated
np.random.shuffle(nest_indices)
# Update nests
for index, pos in zip(nest_indices, new_cuckoo_pos):
self.__nests[index].update_pos(pos)
# Abandon nests randomly considering p_a
for nest in self.__nests:
if np.random.random_sample() < self.__p_a:
nest.abandon()
# Update best nest
current_best = min(self.__nests, key=lambda nest: nest.value)
if current_best.value < best_nest.value:
best_nest = deepcopy(current_best)
LOGGER.info('Iteration %i Found new best solution="%s" at position="%s"', iteration+1, best_nest.value, best_nest.position)
# Add data for plot
positions, abandoned = zip(*[(nest.position, nest.abandoned) for nest in self.__nests])
self.__visualizer.add_data(positions=positions, best_position=current_best.position, abandoned=abandoned)
LOGGER.info('Last best solution="%s" at position="%s"', best_nest.value, best_nest.position)
return best_nest
def replay(self):
"""
Start the problems visualization.
"""
self.__visualizer.replay()
| 40.359551 | 145 | 0.612194 | [
"BSD-3-Clause"
] | Geetha-github-cloud/swarmlib | swarmlib/cuckoosearch/cuckoo_problem.py | 3,592 | Python |
import os
import tensorflow as tf
from merge.model import Model
def run_model_on_random_input(model):
batch_size = 1
height = 100
width = 200
inputs = {
'image': tf.random.uniform(shape=(batch_size, height, width, 3), minval=0, maxval=256, dtype='int32'),
'horz_split_points_probs': tf.random.uniform(shape=(batch_size, height), dtype='float32'),
'vert_split_points_probs': tf.random.uniform(shape=(batch_size, width), dtype='float32'),
'horz_split_points_binary': tf.random.uniform(shape=(batch_size, height), minval=0, maxval=2, dtype='int32'),
'vert_split_points_binary': tf.random.uniform(shape=(batch_size, width), minval=0, maxval=2, dtype='int32')
}
model(inputs)
def load_model(model_file_path, compute_metric):
assert os.path.exists(model_file_path)
model = Model(compute_metric)
run_model_on_random_input(model)
model.load_weights(model_file_path)
# Metric can't be calculated in graph mode.
run_eagerly = True if compute_metric else False
model.compile(run_eagerly=run_eagerly)
return model
def convert_ds_element_to_tuple(element):
input_keys = [
'image',
'horz_split_points_probs',
'vert_split_points_probs',
'horz_split_points_binary',
'vert_split_points_binary'
]
return (
{key: element[key] for key in input_keys},
{
'markup_table': element['markup_table']
}
) | 33.5 | 117 | 0.681818 | [
"MIT"
] | matroshenko/SPLERGE_via_TF | merge/evaluation.py | 1,474 | Python |
from django.contrib import admin
from .models import Post, SurveyHistory
admin.site.register(Post)
admin.site.register(SurveyHistory)
| 22.5 | 39 | 0.82963 | [
"MIT"
] | functioncall/rescue-habit | blog/admin.py | 135 | Python |
"""
Mplot demo runner
"""
import enaml
from enaml.qt.qt_application import QtApplication
def run_demo():
with enaml.imports():
#from griddata_demo_ui import Main
from griddata_demo_model_ui import Main
app = QtApplication()
view = Main(custom_title='Matplotlib demo', mplot_style='darkish')
view.show()
# Start the application event loop
app.start()
run_demo()
| 17.041667 | 70 | 0.691932 | [
"Apache-2.0"
] | viz4biz/PyDataNYC2015 | tutorial/grid_data_demo_run.py | 409 | Python |
import os
import tempfile
from tests.STDF.STDFRecordTest import STDFRecordTest
from STDF import FAR
# File Attributes Record
# Functuion:
# Contains the information necessary to determine
# how to decode the STDF datacontained in the file.
def test_FAR():
far('<')
far('>')
def far(end):
# STDF v4 page 57
record = FAR(endian = end)
# Test serialization
# 1. Save FAR STDF record into a file
# 2. Read byte by byte and compare with expected value
tf = tempfile.NamedTemporaryFile(delete=False)
f = open(tf.name, "wb")
w_data = record.__repr__()
f.write(w_data)
f.close
f = open(tf.name, "rb")
stdfRecTest = STDFRecordTest(f, end)
# rec_len, rec_type, rec_sub
stdfRecTest.assert_file_record_header(2, 0, 10)
# Test REC_CPU, expected value 2
stdfRecTest.assert_ubyte(2);
# Test STDF_VER, expected value 4
stdfRecTest.assert_ubyte(4);
f.close()
# Test de-serialization
# 1. Open STDF record from a file
# 2. Read record fields and compare with the expected value
inst = FAR('V4', end, w_data)
# rec_len, rec_type, rec_sub
stdfRecTest.assert_instance_record_header(inst , 2, 0, 10)
# Test REC_CPU field, position 3, value 2
stdfRecTest.assert_instance_field(inst, 3, 2);
# Test STDF_VER field, position 4, value 4
stdfRecTest.assert_instance_field(inst, 4, 4);
# Test ATDF output
expected_atdf = "FAR:A|4|2|U"
assert inst.to_atdf() == expected_atdf
# ToDo: Test JSON output
os.remove(tf.name)
| 25.209677 | 62 | 0.672425 | [
"MIT"
] | awinia-github/Semi-ATE-STDF | tests/STDF/test_FAR.py | 1,563 | Python |
from academicInfo.models import Department
from faculty.forms import FacultySignupForm
from faculty.models import Faculty
from django.contrib.auth.models import User
from django.test import TestCase
from django.utils import timezone
class FacultySignupFormTest(TestCase):
def test_signup_form_label(self):
form = FacultySignupForm()
self.assertTrue(
form.fields['first_name'].label == 'First Name' and
form.fields['last_name'].label == 'Last Name' and
form.fields['username'].label == 'Roll number' and
form.fields['dob'].label == 'Date of Birth' and
form.fields['department'].label == 'Department' and
form.fields['email'].label == 'Email'
)
def test_signup_form_required_fields(self):
form = FacultySignupForm()
self.assertTrue(
form.fields['first_name'].required == True and
form.fields['last_name'].required == True and
form.fields['dob'].required == True and
form.fields['department'].required == True and
form.fields['email'].required == True
)
def test_invalid_email_validation(self):
startTime = timezone.now()
department = Department.objects.create(name='test department')
user = User.objects.create(
username='test',
email='[email protected]'
)
faculty = Faculty.objects.create(
user=user,
dob=startTime,
department=department
)
form = FacultySignupForm(
data = {
'username': 'test1',
'email': '[email protected]',
'dob': startTime,
'department': department
}
)
self.assertFalse(form.is_valid())
def test_valid_email_validation(self):
startTime = timezone.now()
department = Department.objects.create(name='test department')
form = FacultySignupForm(
data = {
'username': 'test',
'first_name': 'Bob',
'last_name': 'Davidson',
'dob': startTime,
'email': '[email protected]',
'password1': 'complex1password',
'password2': 'complex1password',
'department': department
}
)
self.assertTrue(form.is_valid())
| 32.293333 | 70 | 0.565648 | [
"MIT"
] | shreygoel7/Pinocchio | Pinocchio/faculty/tests/test_forms.py | 2,422 | Python |
#!/usr/bin/env python3
import sys
import re
class Num:
def __init__(self, value):
self.value = value
def __add__(self, num):
return Num(self.value * num.value)
def __mul__(self, num):
return Num(self.value + num.value)
s = 0
for line in sys.stdin:
line = line.replace("+", "$").replace("*", "+").replace("$", "*")
line = re.sub(r"(\d)", r"Num(\1)", line)
s += eval(line).value
print(s)
| 18.375 | 69 | 0.564626 | [
"MIT"
] | pauldraper/advent-of-code-2020 | problems/day-18/part_2.py | 441 | Python |
# -*- coding: utf-8 -*-
import warnings
# warnings.filterwarnings("ignore") # 抑制告警，并指定采取的措施
warnings.warn("# This is a test warning 111.")
print("Hello One")
warnings.filterwarnings("ignore", category=DeprecationWarning) # 抑制特定类型的警告
warnings.warn("# This is a test warning 222.", DeprecationWarning) # 被抑制
warnings.warn("# Something else.") # 未被抑制
print("Hello Two")
warnings.filterwarnings("error") # 将警告转换为错误
warnings.warn("# This is a test warning 333.", DeprecationWarning) # 指定引发的异常
print("Hello Three")
# ### 警告
# 警告不是异常，不影响程序的运行，可用于指示程序的状态；
# 可根据异常来过滤掉特定类型的警告；
# 发出警告时，可指定引发的异常（告警类别必须是Warning的子类）；
| 30.238095 | 78 | 0.707087 | [
"Apache-2.0"
] | anliven/L-Python | Python3-Basics/Chapter11_Exception02_Warning.py | 869 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Script to Test Deep Learning Model.
Contains a pipeline to test a deep learning model.
Revision History:
2021-11-20 (ANI717 - Animesh Bala Ani): Baseline Software.
Example:
$ python3 test.py
"""
#___Import Modules:
import torch
from torch.utils.data import DataLoader
from tqdm import tqdm
import config
from model import NvidiaNet
from dataset import ANI717Dataset
#___Main Method:
def main():
# Load Data
dataset = ANI717Dataset(config.TEST_CSV, config.IMG_SOURCE, transforms=config.TEST_TRANSFORMS)
loader = DataLoader(dataset, batch_size=1, shuffle=False)
# Initialize Model with Weights
model = NvidiaNet(in_channels=config.IMG_SHAPE[0]).to(config.DEVICE)
model.load_state_dict(torch.load(config.MODEL_FILE, map_location=config.DEVICE)["state_dict"])
model.eval()
# Initialize total correct number and counter
num_correct = 0.0
count = 0
# Loop through dataset
with torch.no_grad():
loop = tqdm(loader, position=0, leave=True)
for batch_idx, (inputs, z, x) in enumerate(loop):
# Enable GPU support is available
inputs = inputs.to(config.DEVICE)
if config.TRAIN_TYPE == 'z':
targets = z.unsqueeze(1).to(torch.float32).to(config.DEVICE)
else:
targets = x.unsqueeze(1).to(torch.float32).to(config.DEVICE)
# Calculate prediction
predictions = model(inputs)
# Update total correct number and counter
num_correct += sum(abs(torch.round(targets/config.ERROR_TOLERENCE) - torch.round(predictions/config.ERROR_TOLERENCE)) <= 1).item()
count += predictions.shape[0]
# Calculate accuracy
loop.set_postfix(accuracy=100*num_correct/count)
#___Driver Program:
if __name__ == "__main__":
main()
#
# end of file
"""ANI717""" | 28.148649 | 142 | 0.614498 | [
"MIT"
] | ANI717/Self_Driving_CV_Repository | deep learning/test/test.py | 2,083 | Python |
# -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/stable/config
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
sys.path.insert(0, os.path.abspath('../../'))
print(sys.path)
# -- Project information -----------------------------------------------------
project = u'NiaPy'
copyright = u'2018, NiaOrg'
author = u'Grega Vrbančič, Lucija Brezočnik, Uroš Mlakar, Dušan Fister, Iztok Fister Jr., Klemen Berkovič, Jan Popič'
# The short X.Y version
version = u''
# The full version, including alpha/beta/rc tags
release = u'0.0.0.'
# -- General configuration ---------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.doctest',
'sphinx.ext.intersphinx',
'sphinx.ext.todo',
'sphinx.ext.coverage',
'sphinx.ext.mathjax',
'sphinx.ext.ifconfig',
'sphinx.ext.viewcode',
'sphinx.ext.napoleon'
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path .
exclude_patterns = []
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'sphinx_rtd_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# The default sidebars (for documents that don't match any pattern) are
# defined by theme itself. Builtin themes are using these templates by
# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
# 'searchbox.html']``.
#
# html_sidebars = {}
# -- Options for HTMLHelp output ---------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'NiaPydoc'
# -- Options for LaTeX output ------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'NiaPy.tex', u'NiaPy Documentation',
u'Grega Vrbančič, Lucija Brezočnik, Uroš Mlakar, Dušan Fister, Iztok Fister Jr.', 'manual'),
]
# -- Options for manual page output ------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'niapy', u'NiaPy Documentation',
[author], 1)
]
# -- Options for Texinfo output ----------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'NiaPy', u'NiaPy Documentation',
author, 'NiaPy', 'One line description of project.',
'Miscellaneous'),
]
# -- Extension configuration -------------------------------------------------
autoclass_content = 'both'
# -- Options for intersphinx extension ---------------------------------------
# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {'https://docs.python.org/': None}
# -- Options for todo extension ----------------------------------------------
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = True
# A boolean that decides whether parentheses are appended to function and method role text (e.g. the content of :func:`input`) to signify that the name is callable. Default is True
add_function_parentheses = True
# Napolen settings
# chekc https://sphinxcontrib-napoleon.readthedocs.io/en/latest/sphinxcontrib.napoleon.html
napoleon_google_docstring = True
napoleon_numpy_docstring = False
napoleon_include_init_with_doc = True
napoleon_include_private_with_doc = True
napoleon_include_special_with_doc = True
napoleon_use_admonition_for_examples = False
napoleon_use_admonition_for_notes = False
napoleon_use_admonition_for_references = False
napoleon_use_ivar = True
napoleon_use_param = True
napoleon_use_rtype = True
napoleon_use_keyword = True
napoleon_custom_sections = None
import matplotlib
matplotlib.use('agg')
| 31.816832 | 180 | 0.67232 | [
"MIT"
] | RokPot/NiaPy | docs/source/conf.py | 6,439 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 5/15/20 4:49 PM
# @File : grover.py
# qubit number=4
# total number=8
import cirq
import cirq.google as cg
from typing import Optional
import sys
from math import log2
import numpy as np
#thatsNoCode
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.rx(1.6147786239451536).on(input_qubit[3])) # number=5
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.X.on(input_qubit[1])) # number=6
c.append(cirq.X.on(input_qubit[1])) # number=7
# circuit end
return c
def bitstring(bits):
return ''.join(str(int(b)) for b in bits)
if __name__ == '__main__':
qubit_count = 4
input_qubits = [cirq.GridQubit(i, 0) for i in range(qubit_count)]
circuit = make_circuit(qubit_count,input_qubits)
circuit = cg.optimized_for_sycamore(circuit, optimizer_type='sqrt_iswap')
circuit_sample_count =2000
info = cirq.final_state_vector(circuit)
qubits = round(log2(len(info)))
frequencies = {
np.binary_repr(i, qubits): round((info[i]*(info[i].conjugate())).real,3)
for i in range(2 ** qubits)
}
writefile = open("../data/startCirq_Class18.csv","w+")
print(format(frequencies),file=writefile)
print("results end", file=writefile)
print(circuit.__len__(), file=writefile)
print(circuit,file=writefile)
writefile.close() | 26.4 | 80 | 0.667298 | [
"BSD-3-Clause"
] | UCLA-SEAL/QDiff | data/cirq_new/cirq_program/startCirq_Class18.py | 1,584 | Python |
# simple example demonstrating how to control a Tello using your keyboard.
# For a more fully featured example see manual-control-pygame.py
#
# Use W, A, S, D for moving, E, Q for rotating and R, F for going up and down.
# When starting the script the Tello will takeoff, pressing ESC makes it land
# and the script exit.
# 简单的演示如何用键盘控制Tello
# 欲使用全手动控制请查看 manual-control-pygame.py
#
# W, A, S, D 移动， E, Q 转向，R、F上升与下降.
# 开始运行程序时Tello会自动起飞，按ESC键降落
# 并且程序会退出
from djitellopy import Tello
import cv2, math, time
tello = Tello()
tello.connect()
tello.streamon()
frame_read = tello.get_frame_read()
height, width, _ = frame_read.frame.shape
# tello.takeoff()
nSnap = 0
# w = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
# h = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
w = width
h= height
folder = "."
name = "snapshot"
fileName = "%s/%s_%d_%d_" %(folder, name, w, h)
while True:
# In reality you want to display frames in a seperate thread. Otherwise
# they will freeze while the drone moves.
# 在实际开发里请在另一个线程中显示摄像头画面，否则画面会在无人机移动时静止
img = frame_read.frame
cv2.imshow("drone", img)
# height, width, _ = frame_read.frame.shape
# video = cv2.VideoWriter('video.avi', cv2.VideoWriter_fourcc(*'XVID'), 30, (width, height))
key = cv2.waitKey(1) & 0xff
if key == 27: # ESC
break
elif key == ord('w'):
tello.move_forward(30)
elif key == ord('s'):
tello.move_back(30)
elif key == ord('a'):
tello.move_left(30)
elif key == ord('d'):
tello.move_right(30)
elif key == ord('e'):
tello.rotate_clockwise(30)
elif key == ord('q'):
tello.rotate_counter_clockwise(30)
elif key == ord('r'):
tello.send_command_with_return('downvision 0')
frame_read = tello.get_frame_read()
elif key == ord('f'):
tello.send_command_with_return('downvision 1')
frame_read = tello.get_frame_read()
elif key == ord(' '):
print("Saving image ", nSnap)
cv2.imwrite("%s%d-jpg"%(fileName, nSnap), img)
nSnap += 1
# tello.land()
| 30.057971 | 96 | 0.644648 | [
"MIT"
] | elizabethhng/DJITelloPy | examples/manual-control-opencv.py | 2,264 | Python |
# -*- coding: utf-8 -*-
"""Base exchange class"""
# -----------------------------------------------------------------------------
__version__ = '1.17.322'
# -----------------------------------------------------------------------------
from ccxt.base.errors import ExchangeError
from ccxt.base.errors import NetworkError
from ccxt.base.errors import NotSupported
from ccxt.base.errors import AuthenticationError
from ccxt.base.errors import DDoSProtection
from ccxt.base.errors import RequestTimeout
from ccxt.base.errors import ExchangeNotAvailable
from ccxt.base.errors import InvalidAddress
# -----------------------------------------------------------------------------
from ccxt.base.decimal_to_precision import decimal_to_precision
from ccxt.base.decimal_to_precision import DECIMAL_PLACES, TRUNCATE, ROUND
# -----------------------------------------------------------------------------
__all__ = [
'Exchange',
]
# -----------------------------------------------------------------------------
# Python 2 & 3
import logging
import base64
import calendar
import collections
import datetime
from email.utils import parsedate
import functools
import gzip
import hashlib
import hmac
import io
import json
import math
from numbers import Number
import re
from requests import Session
from requests.utils import default_user_agent
from requests.exceptions import HTTPError, Timeout, TooManyRedirects, RequestException
# import socket
from ssl import SSLError
# import sys
import time
import uuid
import zlib
from decimal import Decimal
# -----------------------------------------------------------------------------
try:
basestring # basestring was removed in python 3.0
except NameError:
basestring = str
# -----------------------------------------------------------------------------
try:
import urllib.parse as _urlencode # Python 3
except ImportError:
import urllib as _urlencode # Python 2
# -----------------------------------------------------------------------------
# web3/0x imports
try:
# from web3.auto import w3
from web3 import Web3, HTTPProvider
from web3.utils.encoding import hex_encode_abi_type
except ImportError:
Web3 = HTTPProvider = None # web3/0x not supported in Python 2
# -----------------------------------------------------------------------------
class Exchange(object):
"""Base exchange class"""
id = None
version = None
certified = False
# rate limiter settings
enableRateLimit = False
rateLimit = 2000 # milliseconds = seconds * 1000
timeout = 10000 # milliseconds = seconds * 1000
asyncio_loop = None
aiohttp_proxy = None
aiohttp_trust_env = False
session = None # Session () by default
logger = None # logging.getLogger(__name__) by default
userAgent = None
userAgents = {
'chrome': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36',
'chrome39': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36',
}
verbose = False
markets = None
symbols = None
fees = {
'trading': {
'fee_loaded': False,
'percentage': True, # subclasses should rarely have to redefine this
},
'funding': {
'fee_loaded': False,
'withdraw': {},
'deposit': {},
},
}
ids = None
tickers = None
api = None
parseJsonResponse = True
proxy = ''
origin = '*' # CORS origin
proxies = None
hostname = None # in case of inaccessibility of the "main" domain
apiKey = ''
secret = ''
password = ''
uid = ''
privateKey = '' # a "0x"-prefixed hexstring private key for a wallet
walletAddress = '' # the wallet address "0x"-prefixed hexstring
twofa = False
marketsById = None
markets_by_id = None
currencies_by_id = None
precision = None
limits = None
exceptions = None
httpExceptions = {
'422': ExchangeError,
'418': DDoSProtection,
'429': DDoSProtection,
'404': ExchangeNotAvailable,
'409': ExchangeNotAvailable,
'500': ExchangeNotAvailable,
'501': ExchangeNotAvailable,
'502': ExchangeNotAvailable,
'520': ExchangeNotAvailable,
'521': ExchangeNotAvailable,
'522': ExchangeNotAvailable,
'525': ExchangeNotAvailable,
'400': ExchangeNotAvailable,
'403': ExchangeNotAvailable,
'405': ExchangeNotAvailable,
'503': ExchangeNotAvailable,
'530': ExchangeNotAvailable,
'408': RequestTimeout,
'504': RequestTimeout,
'401': AuthenticationError,
'511': AuthenticationError,
}
headers = None
balance = None
orderbooks = None
orders = None
trades = None
transactions = None
currencies = None
options = None # Python does not allow to define properties in run-time with setattr
requiredCredentials = {
'apiKey': True,
'secret': True,
'uid': False,
'login': False,
'password': False,
'twofa': False, # 2-factor authentication (one-time password key)
'privateKey': False, # a "0x"-prefixed hexstring private key for a wallet
'walletAddress': False, # the wallet address "0x"-prefixed hexstring
}
# API method metainfo
has = {
'publicAPI': True,
'privateAPI': True,
'CORS': False,
'cancelOrder': True,
'cancelOrders': False,
'createDepositAddress': False,
'createOrder': True,
'createMarketOrder': True,
'createLimitOrder': True,
'deposit': False,
'editOrder': 'emulated',
'fetchBalance': True,
'fetchClosedOrders': False,
'fetchCurrencies': False,
'fetchDepositAddress': False,
'fetchDeposits': False,
'fetchFundingFees': False,
'fetchL2OrderBook': True,
'fetchMarkets': True,
'fetchMyTrades': False,
'fetchOHLCV': 'emulated',
'fetchOpenOrders': False,
'fetchOrder': False,
'fetchOrderBook': True,
'fetchOrderBooks': False,
'fetchOrders': False,
'fetchTicker': True,
'fetchTickers': False,
'fetchTrades': True,
'fetchTradingFees': False,
'fetchTradingLimits': False,
'fetchTransactions': False,
'fetchWithdrawals': False,
'withdraw': False,
}
precisionMode = DECIMAL_PLACES
minFundingAddressLength = 1 # used in check_address
substituteCommonCurrencyCodes = True
lastRestRequestTimestamp = 0
lastRestPollTimestamp = 0
restRequestQueue = None
restPollerLoopIsRunning = False
rateLimitTokens = 16
rateLimitMaxTokens = 16
rateLimitUpdateTime = 0
enableLastHttpResponse = True
enableLastJsonResponse = True
enableLastResponseHeaders = True
last_http_response = None
last_json_response = None
last_response_headers = None
web3 = None
commonCurrencies = {
'XBT': 'BTC',
'BCC': 'BCH',
'DRK': 'DASH',
}
def __init__(self, config={}):
self.precision = dict() if self.precision is None else self.precision
self.limits = dict() if self.limits is None else self.limits
self.exceptions = dict() if self.exceptions is None else self.exceptions
self.headers = dict() if self.headers is None else self.headers
self.balance = dict() if self.balance is None else self.balance
self.orderbooks = dict() if self.orderbooks is None else self.orderbooks
self.orders = dict() if self.orders is None else self.orders
self.trades = dict() if self.trades is None else self.trades
self.transactions = dict() if self.transactions is None else self.transactions
self.currencies = dict() if self.currencies is None else self.currencies
self.options = dict() if self.options is None else self.options # Python does not allow to define properties in run-time with setattr
self.decimalToPrecision = self.decimal_to_precision = decimal_to_precision
# version = '.'.join(map(str, sys.version_info[:3]))
# self.userAgent = {
# 'User-Agent': 'ccxt/' + __version__ + ' (+https://github.com/ccxt/ccxt) Python/' + version
# }
self.userAgent = default_user_agent()
settings = self.deep_extend(self.describe(), config)
for key in settings:
if hasattr(self, key) and isinstance(getattr(self, key), dict):
setattr(self, key, self.deep_extend(getattr(self, key), settings[key]))
else:
setattr(self, key, settings[key])
if self.api:
self.define_rest_api(self.api, 'request')
if self.markets:
self.set_markets(self.markets)
# convert all properties from underscore notation foo_bar to camelcase notation fooBar
for name in dir(self):
if name[0] != '_'and name[-1] != '_' and '_' in name:
parts = name.split('_')
camelcase = parts[0] + ''.join(self.capitalize(i) for i in parts[1:])
setattr(self, camelcase, getattr(self, name))
self.tokenBucket = self.extend({
'refillRate': 1.0 / self.rateLimit,
'delay': 1.0,
'capacity': 1.0,
'defaultCost': 1.0,
}, getattr(self, 'tokenBucket') if hasattr(self, 'tokenBucket') else {})
self.session = self.session if self.session else Session()
self.logger = self.logger if self.logger else logging.getLogger(__name__)
if Web3 and not self.web3:
# self.web3 = w3 if w3 else Web3(HTTPProvider())
self.web3 = Web3(HTTPProvider())
def __del__(self):
if self.session:
self.session.close()
def describe(self):
return {}
def define_rest_api(self, api, method_name, options={}):
delimiters = re.compile('[^a-zA-Z0-9]')
for api_type, methods in api.items():
for http_method, urls in methods.items():
for url in urls:
url = url.strip()
split_path = delimiters.split(url)
uppercase_method = http_method.upper()
lowercase_method = http_method.lower()
camelcase_method = lowercase_method.capitalize()
camelcase_suffix = ''.join([Exchange.capitalize(x) for x in split_path])
lowercase_path = [x.strip().lower() for x in split_path]
underscore_suffix = '_'.join([k for k in lowercase_path if len(k)])
camelcase = api_type + camelcase_method + Exchange.capitalize(camelcase_suffix)
underscore = api_type + '_' + lowercase_method + '_' + underscore_suffix.lower()
if 'suffixes' in options:
if 'camelcase' in options['suffixes']:
camelcase += options['suffixes']['camelcase']
if 'underscore' in options['suffixes']:
underscore += options['suffixes']['underscore']
partial = functools.partial(getattr(self, method_name), url, api_type, uppercase_method)
setattr(self, camelcase, partial)
setattr(self, underscore, partial)
def raise_error(self, exception_type, url=None, method=None, error=None, details=None):
if error:
error = str(error)
output = ' '.join([self.id] + [var for var in (url, method, error, details) if var is not None])
raise exception_type(output)
def throttle(self):
now = float(self.milliseconds())
elapsed = now - self.lastRestRequestTimestamp
if elapsed < self.rateLimit:
delay = self.rateLimit - elapsed
time.sleep(delay / 1000.0)
def fetch2(self, path, api='public', method='GET', params={}, headers=None, body=None):
"""A better wrapper over request for deferred signing"""
if self.enableRateLimit:
self.throttle()
self.lastRestRequestTimestamp = self.milliseconds()
request = self.sign(path, api, method, params, headers, body)
return self.fetch(request['url'], request['method'], request['headers'], request['body'])
def request(self, path, api='public', method='GET', params={}, headers=None, body=None):
return self.fetch2(path, api, method, params, headers, body)
@staticmethod
def gzip_deflate(response, text):
encoding = response.info().get('Content-Encoding')
if encoding in ('gzip', 'x-gzip', 'deflate'):
if encoding == 'deflate':
return zlib.decompress(text, -zlib.MAX_WBITS)
else:
return gzip.GzipFile('', 'rb', 9, io.BytesIO(text)).read()
return text
def find_broadly_matched_key(self, broad, string):
"""A helper method for matching error strings exactly vs broadly"""
keys = list(broad.keys())
for i in range(0, len(keys)):
key = keys[i]
if string.find(key) >= 0:
return key
return None
def handle_errors(self, code, reason, url, method, headers, body):
pass
def prepare_request_headers(self, headers=None):
headers = headers or {}
headers.update(self.headers)
if self.userAgent:
if type(self.userAgent) is str:
headers.update({'User-Agent': self.userAgent})
elif (type(self.userAgent) is dict) and ('User-Agent' in self.userAgent):
headers.update(self.userAgent)
if self.proxy:
headers.update({'Origin': self.origin})
headers.update({'Accept-Encoding': 'gzip, deflate'})
return headers
def fetch(self, url, method='GET', headers=None, body=None):
"""Perform a HTTP request and return decoded JSON data"""
request_headers = self.prepare_request_headers(headers)
url = self.proxy + url
if self.verbose:
print("\nRequest:", method, url, request_headers, body)
self.logger.debug("%s %s, Request: %s %s", method, url, request_headers, body)
if body:
body = body.encode()
self.session.cookies.clear()
response = None
http_response = None
try:
response = self.session.request(
method,
url,
data=body,
headers=request_headers,
timeout=int(self.timeout / 1000),
proxies=self.proxies
)
http_response = response.text
if self.enableLastHttpResponse:
self.last_http_response = http_response
headers = response.headers
if self.enableLastResponseHeaders:
self.last_response_headers = headers
if self.verbose:
print("\nResponse:", method, url, str(response.status_code), str(headers), http_response)
self.logger.debug("%s %s, Response: %s %s %s", method, url, response.status_code, headers, http_response)
response.raise_for_status()
except Timeout as e:
self.raise_error(RequestTimeout, method, url, e)
except TooManyRedirects as e:
self.raise_error(ExchangeError, url, method, e)
except SSLError as e:
self.raise_error(ExchangeError, url, method, e)
except HTTPError as e:
self.handle_errors(response.status_code, response.reason, url, method, headers, http_response)
self.handle_rest_errors(e, response.status_code, http_response, url, method)
self.raise_error(ExchangeError, url, method, e, http_response)
except RequestException as e: # base exception class
error_string = str(e)
if ('ECONNRESET' in error_string) or ('Connection aborted.' in error_string):
self.raise_error(NetworkError, url, method, e)
else:
self.raise_error(ExchangeError, url, method, e)
self.handle_errors(response.status_code, response.reason, url, method, None, http_response)
return self.handle_rest_response(http_response, url, method, headers, body)
def handle_rest_errors(self, exception, http_status_code, response, url, method='GET'):
error = None
string_code = str(http_status_code)
if string_code in self.httpExceptions:
error = self.httpExceptions[string_code]
if error == ExchangeNotAvailable:
if re.search('(cloudflare|incapsula|overload|ddos)', response, flags=re.IGNORECASE):
error = DDoSProtection
if error:
self.raise_error(error, url, method, exception if exception else http_status_code, response)
def handle_rest_response(self, response, url, method='GET', headers=None, body=None):
try:
if self.parseJsonResponse:
json_response = json.loads(response) if len(response) > 1 else None
if self.enableLastJsonResponse:
self.last_json_response = json_response
return json_response
else:
return response
except ValueError as e: # ValueError == JsonDecodeError
ddos_protection = re.search('(cloudflare|incapsula|overload|ddos)', response, flags=re.IGNORECASE)
exchange_not_available = re.search('(offline|busy|retry|wait|unavailable|maintain|maintenance|maintenancing)', response, flags=re.IGNORECASE)
if ddos_protection:
self.raise_error(DDoSProtection, method, url, None, response)
if exchange_not_available:
message = response + ' exchange downtime, exchange closed for maintenance or offline, DDoS protection or rate-limiting in effect'
self.raise_error(ExchangeNotAvailable, method, url, None, message)
self.raise_error(ExchangeError, method, url, e, response)
@staticmethod
def safe_float(dictionary, key, default_value=None):
value = default_value
try:
if isinstance(dictionary, list) and isinstance(key, int) and len(dictionary) > key:
value = float(dictionary[key])
else:
value = float(dictionary[key]) if (key is not None) and (key in dictionary) and (dictionary[key] is not None) else default_value
except ValueError as e:
value = default_value
return value
@staticmethod
def safe_string(dictionary, key, default_value=None):
return str(dictionary[key]) if key is not None and (key in dictionary) and dictionary[key] is not None else default_value
@staticmethod
def safe_integer(dictionary, key, default_value=None):
if key is None or (key not in dictionary):
return default_value
value = dictionary[key]
if isinstance(value, Number) or (isinstance(value, basestring) and value.isnumeric()):
return int(value)
return default_value
@staticmethod
def safe_value(dictionary, key, default_value=None):
return dictionary[key] if key is not None and (key in dictionary) and dictionary[key] is not None else default_value
# we're not using safe_floats with a list argument as we're trying to save some cycles here
# we're not using safe_float_3 either because those cases are too rare to deserve their own optimization
@staticmethod
def safe_float_2(dictionary, key1, key2, default_value=None):
return Exchange.safe_either(Exchange.safe_float, dictionary, key1, key2, default_value)
@staticmethod
def safe_string_2(dictionary, key1, key2, default_value=None):
return Exchange.safe_either(Exchange.safe_string, dictionary, key1, key2, default_value)
@staticmethod
def safe_integer_2(dictionary, key1, key2, default_value=None):
return Exchange.safe_either(Exchange.safe_integer, dictionary, key1, key2, default_value)
@staticmethod
def safe_value_2(dictionary, key1, key2, default_value=None):
return Exchange.safe_either(Exchange.safe_value, dictionary, key1, key2, default_value)
@staticmethod
def safe_either(method, dictionary, key1, key2, default_value=None):
"""A helper-wrapper for the safe_value_2() family."""
value = method(dictionary, key1)
return value if value is not None else method(dictionary, key2, default_value)
@staticmethod
def truncate(num, precision=0):
"""Deprecated, use decimal_to_precision instead"""
if precision > 0:
decimal_precision = math.pow(10, precision)
return math.trunc(num * decimal_precision) / decimal_precision
return int(Exchange.truncate_to_string(num, precision))
@staticmethod
def truncate_to_string(num, precision=0):
"""Deprecated, todo: remove references from subclasses"""
if precision > 0:
parts = ('{0:.%df}' % precision).format(Decimal(num)).split('.')
decimal_digits = parts[1][:precision].rstrip('0')
decimal_digits = decimal_digits if len(decimal_digits) else '0'
return parts[0] + '.' + decimal_digits
return ('%d' % num)
@staticmethod
def uuid():
return str(uuid.uuid4())
@staticmethod
def capitalize(string): # first character only, rest characters unchanged
# the native pythonic .capitalize() method lowercases all other characters
# which is an unwanted behaviour, therefore we use this custom implementation
# check it yourself: print('foobar'.capitalize(), 'fooBar'.capitalize())
if len(string) > 1:
return "%s%s" % (string[0].upper(), string[1:])
return string.upper()
@staticmethod
def keysort(dictionary):
return collections.OrderedDict(sorted(dictionary.items(), key=lambda t: t[0]))
@staticmethod
def extend(*args):
if args is not None:
result = None
if type(args[0]) is collections.OrderedDict:
result = collections.OrderedDict()
else:
result = {}
for arg in args:
result.update(arg)
return result
return {}
@staticmethod
def deep_extend(*args):
result = None
for arg in args:
if isinstance(arg, dict):
if not isinstance(result, dict):
result = {}
for key in arg:
result[key] = Exchange.deep_extend(result[key] if key in result else None, arg[key])
else:
result = arg
return result
@staticmethod
def filter_by(array, key, value=None):
if value:
grouped = Exchange.group_by(array, key)
if value in grouped:
return grouped[value]
return []
return array
@staticmethod
def filterBy(self, array, key, value=None):
return Exchange.filter_by(array, key, value)
@staticmethod
def group_by(array, key):
result = {}
array = Exchange.to_array(array)
array = [entry for entry in array if (key in entry) and (entry[key] is not None)]
for entry in array:
if entry[key] not in result:
result[entry[key]] = []
result[entry[key]].append(entry)
return result
@staticmethod
def groupBy(array, key):
return Exchange.group_by(array, key)
@staticmethod
def index_by(array, key):
result = {}
if type(array) is dict:
array = Exchange.keysort(array).values()
for element in array:
if (key in element) and (element[key] is not None):
k = element[key]
result[k] = element
return result
@staticmethod
def sort_by(array, key, descending=False):
return sorted(array, key=lambda k: k[key] if k[key] is not None else "", reverse=descending)
@staticmethod
def array_concat(a, b):
return a + b
@staticmethod
def in_array(needle, haystack):
return needle in haystack
@staticmethod
def is_empty(object):
return not object
@staticmethod
def extract_params(string):
return re.findall(r'{([\w-]+)}', string)
@staticmethod
def implode_params(string, params):
for key in params:
string = string.replace('{' + key + '}', str(params[key]))
return string
@staticmethod
def url(path, params={}):
result = Exchange.implode_params(path, params)
query = Exchange.omit(params, Exchange.extract_params(path))
if query:
result += '?' + _urlencode.urlencode(query)
return result
@staticmethod
def urlencode(params={}):
if (type(params) is dict) or isinstance(params, collections.OrderedDict):
return _urlencode.urlencode(params)
return params
@staticmethod
def rawencode(params={}):
return _urlencode.unquote(Exchange.urlencode(params))
@staticmethod
def encode_uri_component(uri):
return _urlencode.quote(uri, safe="~()*!.'")
@staticmethod
def omit(d, *args):
result = d.copy()
for arg in args:
if type(arg) is list:
for key in arg:
if key in result:
del result[key]
else:
if arg in result:
del result[arg]
return result
@staticmethod
def unique(array):
return list(set(array))
@staticmethod
def pluck(array, key):
return [
element[key]
for element in array
if (key in element) and (element[key] is not None)
]
@staticmethod
def sum(*args):
return sum([arg for arg in args if isinstance(arg, (float, int))])
@staticmethod
def ordered(array):
return collections.OrderedDict(array)
@staticmethod
def aggregate(bidasks):
ordered = Exchange.ordered({})
for [price, volume] in bidasks:
if volume > 0:
ordered[price] = (ordered[price] if price in ordered else 0) + volume
result = []
items = list(ordered.items())
for price, volume in items:
result.append([price, volume])
return result
@staticmethod
def sec():
return Exchange.seconds()
@staticmethod
def msec():
return Exchange.milliseconds()
@staticmethod
def usec():
return Exchange.microseconds()
@staticmethod
def seconds():
return int(time.time())
@staticmethod
def milliseconds():
return int(time.time() * 1000)
@staticmethod
def microseconds():
return int(time.time() * 1000000)
@staticmethod
def iso8601(timestamp=None):
if timestamp is None:
return timestamp
if not isinstance(timestamp, int):
return None
if int(timestamp) < 0:
return None
try:
utc = datetime.datetime.utcfromtimestamp(timestamp // 1000)
return utc.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-6] + "{:03d}".format(int(timestamp) % 1000) + 'Z'
except (TypeError, OverflowError, OSError):
return None
@staticmethod
def dmy(timestamp, infix='-'):
utc_datetime = datetime.datetime.utcfromtimestamp(int(round(timestamp / 1000)))
return utc_datetime.strftime('%m' + infix + '%d' + infix + '%Y')
@staticmethod
def ymd(timestamp, infix='-'):
utc_datetime = datetime.datetime.utcfromtimestamp(int(round(timestamp / 1000)))
return utc_datetime.strftime('%Y' + infix + '%m' + infix + '%d')
@staticmethod
def ymdhms(timestamp, infix=' '):
utc_datetime = datetime.datetime.utcfromtimestamp(int(round(timestamp / 1000)))
return utc_datetime.strftime('%Y-%m-%d' + infix + '%H:%M:%S')
@staticmethod
def parse_date(timestamp=None):
if timestamp is None:
return timestamp
if not isinstance(timestamp, str):
return None
if 'GMT' in timestamp:
try:
string = ''.join([str(value) for value in parsedate(timestamp)[:6]]) + '.000Z'
dt = datetime.datetime.strptime(string, "%Y%m%d%H%M%S.%fZ")
return calendar.timegm(dt.utctimetuple()) * 1000
except (TypeError, OverflowError, OSError):
return None
else:
return Exchange.parse8601(timestamp)
@staticmethod
def parse8601(timestamp=None):
if timestamp is None:
return timestamp
yyyy = '([0-9]{4})-?'
mm = '([0-9]{2})-?'
dd = '([0-9]{2})(?:T|[\\s])?'
h = '([0-9]{2}):?'
m = '([0-9]{2}):?'
s = '([0-9]{2})'
ms = '(\\.[0-9]{1,3})?'
tz = '(?:(\\+|\\-)([0-9]{2})\\:?([0-9]{2})|Z)?'
regex = r'' + yyyy + mm + dd + h + m + s + ms + tz
try:
match = re.search(regex, timestamp, re.IGNORECASE)
if match is None:
return None
yyyy, mm, dd, h, m, s, ms, sign, hours, minutes = match.groups()
ms = ms or '.000'
msint = int(ms[1:])
sign = sign or ''
sign = int(sign + '1')
hours = int(hours or 0) * sign
minutes = int(minutes or 0) * sign
offset = datetime.timedelta(hours=hours, minutes=minutes)
string = yyyy + mm + dd + h + m + s + ms + 'Z'
dt = datetime.datetime.strptime(string, "%Y%m%d%H%M%S.%fZ")
dt = dt + offset
return calendar.timegm(dt.utctimetuple()) * 1000 + msint
except (TypeError, OverflowError, OSError, ValueError):
return None
@staticmethod
def hash(request, algorithm='md5', digest='hex'):
h = hashlib.new(algorithm, request)
if digest == 'hex':
return h.hexdigest()
elif digest == 'base64':
return base64.b64encode(h.digest())
return h.digest()
@staticmethod
def hmac(request, secret, algorithm=hashlib.sha256, digest='hex'):
h = hmac.new(secret, request, algorithm)
if digest == 'hex':
return h.hexdigest()
elif digest == 'base64':
return base64.b64encode(h.digest())
return h.digest()
@staticmethod
def binary_concat(*args):
result = bytes()
for arg in args:
result = result + arg
return result
@staticmethod
def binary_to_string(s):
return s.decode('ascii')
@staticmethod
def base64urlencode(s):
return Exchange.decode(base64.urlsafe_b64encode(s)).replace('=', '')
@staticmethod
def jwt(request, secret, algorithm=hashlib.sha256, alg='HS256'):
header = Exchange.encode(Exchange.json({
'alg': alg,
'typ': 'JWT',
}))
encodedHeader = Exchange.base64urlencode(header)
encodedData = Exchange.base64urlencode(Exchange.encode(Exchange.json(request)))
token = encodedHeader + '.' + encodedData
hmac = Exchange.hmac(Exchange.encode(token), Exchange.encode(secret), algorithm, 'binary')
signature = Exchange.base64urlencode(hmac)
return token + '.' + signature
@staticmethod
def unjson(input):
return json.loads(input)
@staticmethod
def json(data, params=None):
return json.dumps(data, separators=(',', ':'))
@staticmethod
def parse_if_json_encoded_object(input):
return json.loads(input) if Exchange.is_json_encoded_object(input) else input
@staticmethod
def is_json_encoded_object(input):
return (isinstance(input, basestring) and
(len(input) >= 2) and
((input[0] == '{') or (input[0] == '[')))
@staticmethod
def encode(string):
return string.encode()
@staticmethod
def decode(string):
return string.decode()
@staticmethod
def to_array(value):
return list(value.values()) if type(value) is dict else value
def nonce(self):
return Exchange.seconds()
def check_required_credentials(self):
keys = list(self.requiredCredentials.keys())
for key in keys:
if self.requiredCredentials[key] and not getattr(self, key):
self.raise_error(AuthenticationError, details='requires `' + key + '`')
def check_address(self, address):
"""Checks an address is not the same character repeated or an empty sequence"""
if address is None:
self.raise_error(InvalidAddress, details='address is None')
if all(letter == address[0] for letter in address) or len(address) < self.minFundingAddressLength or ' ' in address:
self.raise_error(InvalidAddress, details='address is invalid or has less than ' + str(self.minFundingAddressLength) + ' characters: "' + str(address) + '"')
return address
def account(self):
return {
'free': 0.0,
'used': 0.0,
'total': 0.0,
}
def common_currency_code(self, currency):
if not self.substituteCommonCurrencyCodes:
return currency
return self.safe_string(self.commonCurrencies, currency, currency)
def currency_id(self, commonCode):
if self.currencies:
if commonCode in self.currencies:
return self.currencies[commonCode]['id']
currencyIds = {v: k for k, v in self.commonCurrencies.items()}
return self.safe_string(currencyIds, commonCode, commonCode)
def fromWei(self, amount, unit='ether'):
if Web3 is None:
self.raise_error(NotSupported, details="ethereum web3 methods require Python 3: https://pythonclock.org")
if amount is None:
return amount
return float(Web3.fromWei(int(amount), unit))
def toWei(self, amount, unit='ether'):
if Web3 is None:
self.raise_error(NotSupported, details="ethereum web3 methods require Python 3: https://pythonclock.org")
if amount is None:
return amount
return str(Web3.toWei(int(amount), unit))
def precision_from_string(self, string):
parts = re.sub(r'0+$', '', string).split('.')
return len(parts[1]) if len(parts) > 1 else 0
def cost_to_precision(self, symbol, cost):
return self.decimal_to_precision(cost, ROUND, self.markets[symbol]['precision']['price'], self.precisionMode)
def price_to_precision(self, symbol, price):
return self.decimal_to_precision(price, ROUND, self.markets[symbol]['precision']['price'], self.precisionMode)
def amount_to_precision(self, symbol, amount):
return self.decimal_to_precision(amount, TRUNCATE, self.markets[symbol]['precision']['amount'], self.precisionMode)
def fee_to_precision(self, symbol, fee):
return self.decimal_to_precision(fee, ROUND, self.markets[symbol]['precision']['price'], self.precisionMode)
def currency_to_precision(self, currency, fee):
return self.decimal_to_precision(fee, ROUND, self.currencies[currency]['precision'], self.precisionMode)
def set_markets(self, markets, currencies=None):
values = list(markets.values()) if type(markets) is dict else markets
for i in range(0, len(values)):
values[i] = self.extend(
self.fees['trading'],
{'precision': self.precision, 'limits': self.limits},
values[i]
)
self.markets = self.index_by(values, 'symbol')
self.markets_by_id = self.index_by(values, 'id')
self.marketsById = self.markets_by_id
self.symbols = sorted(list(self.markets.keys()))
self.ids = sorted(list(self.markets_by_id.keys()))
if currencies:
self.currencies = self.deep_extend(currencies, self.currencies)
else:
base_currencies = [{
'id': market['baseId'] if 'baseId' in market else market['base'],
'numericId': market['baseNumericId'] if 'baseNumericId' in market else None,
'code': market['base'],
'precision': (
market['precision']['base'] if 'base' in market['precision'] else (
market['precision']['amount'] if 'amount' in market['precision'] else None
)
) if 'precision' in market else 8,
} for market in values if 'base' in market]
quote_currencies = [{
'id': market['quoteId'] if 'quoteId' in market else market['quote'],
'numericId': market['quoteNumericId'] if 'quoteNumericId' in market else None,
'code': market['quote'],
'precision': (
market['precision']['quote'] if 'quote' in market['precision'] else (
market['precision']['price'] if 'price' in market['precision'] else None
)
) if 'precision' in market else 8,
} for market in values if 'quote' in market]
currencies = self.sort_by(base_currencies + quote_currencies, 'code')
self.currencies = self.deep_extend(self.index_by(currencies, 'code'), self.currencies)
self.currencies_by_id = self.index_by(list(self.currencies.values()), 'id')
return self.markets
def load_markets(self, reload=False):
if not reload:
if self.markets:
if not self.markets_by_id:
return self.set_markets(self.markets)
return self.markets
markets = self.fetch_markets()
currencies = None
if self.has['fetchCurrencies']:
currencies = self.fetch_currencies()
return self.set_markets(markets, currencies)
def populate_fees(self):
if not (hasattr(self, 'markets') or hasattr(self, 'currencies')):
return
for currency, data in self.currencies.items(): # try load withdrawal fees from currencies
if 'fee' in data and data['fee'] is not None:
self.fees['funding']['withdraw'][currency] = data['fee']
self.fees['funding']['fee_loaded'] = True
# find a way to populate trading fees from markets
def load_fees(self):
self.load_markets()
self.populate_fees()
if not (self.has['fetchTradingFees'] or self.has['fetchFundingFees']):
return self.fees
fetched_fees = self.fetch_fees()
if fetched_fees['funding']:
self.fees['funding']['fee_loaded'] = True
if fetched_fees['trading']:
self.fees['trading']['fee_loaded'] = True
self.fees = self.deep_extend(self.fees, fetched_fees)
return self.fees
def fetch_markets(self):
# markets are returned as a list
# currencies are returned as a dict
# this is for historical reasons
# and may be changed for consistency later
return self.to_array(self.markets)
def fetch_currencies(self, params={}):
# markets are returned as a list
# currencies are returned as a dict
# this is for historical reasons
# and may be changed for consistency later
return self.currencies
def fetch_fees(self):
trading = {}
funding = {}
try:
trading = self.fetch_trading_fees()
except AuthenticationError:
pass
except AttributeError:
pass
try:
funding = self.fetch_funding_fees()
except AuthenticationError:
pass
except AttributeError:
pass
return {
'trading': trading,
'funding': funding,
}
def create_order(self, symbol, type, side, amount, price=None, params={}):
self.raise_error(NotSupported, details='create_order() not implemented yet')
def cancel_order(self, id, symbol=None, params={}):
self.raise_error(NotSupported, details='cancel_order() not implemented yet')
def fetch_bids_asks(self, symbols=None, params={}):
self.raise_error(NotSupported, details='API does not allow to fetch all prices at once with a single call to fetch_bids_asks() for now')
def fetch_tickers(self, symbols=None, params={}):
self.raise_error(NotSupported, details='API does not allow to fetch all tickers at once with a single call to fetch_tickers() for now')
def fetch_order_status(self, id, market=None):
order = self.fetch_order(id)
return order['status']
def purge_cached_orders(self, before):
orders = self.to_array(self.orders)
orders = [order for order in orders if (order['status'] == 'open') or (order['timestamp'] >= before)]
self.orders = self.index_by(orders, 'id')
return self.orders
def fetch_order(self, id, symbol=None, params={}):
self.raise_error(NotSupported, details='fetch_order() is not implemented yet')
def fetch_orders(self, symbol=None, since=None, limit=None, params={}):
self.raise_error(NotSupported, details='fetch_orders() is not implemented yet')
def fetch_open_orders(self, symbol=None, since=None, limit=None, params={}):
self.raise_error(NotSupported, details='fetch_open_orders() is not implemented yet')
def fetch_closed_orders(self, symbol=None, since=None, limit=None, params={}):
self.raise_error(NotSupported, details='fetch_closed_orders() is not implemented yet')
def fetch_my_trades(self, symbol=None, since=None, limit=None, params={}):
self.raise_error(NotSupported, details='fetch_my_trades() is not implemented yet')
def fetch_order_trades(self, id, symbol=None, params={}):
self.raise_error(NotSupported, details='fetch_order_trades() is not implemented yet')
def fetch_transactions(self, symbol=None, since=None, limit=None, params={}):
self.raise_error(NotSupported, details='fetch_transactions() is not implemented yet')
def fetch_deposits(self, symbol=None, since=None, limit=None, params={}):
self.raise_error(NotSupported, details='fetch_deposits() is not implemented yet')
def fetch_withdrawals(self, symbol=None, since=None, limit=None, params={}):
self.raise_error(NotSupported, details='fetch_withdrawals() is not implemented yet')
def parse_ohlcv(self, ohlcv, market=None, timeframe='1m', since=None, limit=None):
return ohlcv[0:6] if isinstance(ohlcv, list) else ohlcv
def parse_ohlcvs(self, ohlcvs, market=None, timeframe='1m', since=None, limit=None):
ohlcvs = self.to_array(ohlcvs)
num_ohlcvs = len(ohlcvs)
result = []
i = 0
while i < num_ohlcvs:
if limit and (len(result) >= limit):
break
ohlcv = self.parse_ohlcv(ohlcvs[i], market, timeframe, since, limit)
i = i + 1
if since and (ohlcv[0] < since):
continue
result.append(ohlcv)
return self.sort_by(result, 0)
def parse_bid_ask(self, bidask, price_key=0, amount_key=0):
return [float(bidask[price_key]), float(bidask[amount_key])]
def parse_bids_asks(self, bidasks, price_key=0, amount_key=1):
result = []
if len(bidasks):
if type(bidasks[0]) is list:
for bidask in bidasks:
if bidask[price_key] and bidask[amount_key]:
result.append(self.parse_bid_ask(bidask, price_key, amount_key))
elif type(bidasks[0]) is dict:
for bidask in bidasks:
if (price_key in bidask) and (amount_key in bidask) and (bidask[price_key] and bidask[amount_key]):
result.append(self.parse_bid_ask(bidask, price_key, amount_key))
else:
self.raise_error(ExchangeError, details='unrecognized bidask format: ' + str(bidasks[0]))
return result
def fetch_l2_order_book(self, symbol, limit=None, params={}):
orderbook = self.fetch_order_book(symbol, limit, params)
return self.extend(orderbook, {
'bids': self.sort_by(self.aggregate(orderbook['bids']), 0, True),
'asks': self.sort_by(self.aggregate(orderbook['asks']), 0),
})
def parse_order_book(self, orderbook, timestamp=None, bids_key='bids', asks_key='asks', price_key=0, amount_key=1):
return {
'bids': self.sort_by(self.parse_bids_asks(orderbook[bids_key], price_key, amount_key) if (bids_key in orderbook) and isinstance(orderbook[bids_key], list) else [], 0, True),
'asks': self.sort_by(self.parse_bids_asks(orderbook[asks_key], price_key, amount_key) if (asks_key in orderbook) and isinstance(orderbook[asks_key], list) else [], 0),
'timestamp': timestamp,
'datetime': self.iso8601(timestamp) if timestamp is not None else None,
'nonce': None,
}
def parse_balance(self, balance):
currencies = self.omit(balance, 'info').keys()
for account in ['free', 'used', 'total']:
balance[account] = {}
for currency in currencies:
balance[account][currency] = balance[currency][account]
return balance
def fetch_partial_balance(self, part, params={}):
balance = self.fetch_balance(params)
return balance[part]
def fetch_free_balance(self, params={}):
return self.fetch_partial_balance('free', params)
def fetch_used_balance(self, params={}):
return self.fetch_partial_balance('used', params)
def fetch_total_balance(self, params={}):
return self.fetch_partial_balance('total', params)
def load_trading_limits(self, symbols=None, reload=False, params={}):
if self.has['fetchTradingLimits']:
if reload or not('limitsLoaded' in list(self.options.keys())):
response = self.fetch_trading_limits(symbols)
for i in range(0, len(symbols)):
symbol = symbols[i]
self.markets[symbol] = self.deep_extend(self.markets[symbol], response[symbol])
self.options['limitsLoaded'] = self.milliseconds()
return self.markets
def fetch_ohlcv(self, symbol, timeframe='1m', since=None, limit=None, params={}):
if not self.has['fetchTrades']:
self.raise_error(NotSupported, details='fetch_ohlcv() not implemented yet')
self.load_markets()
trades = self.fetch_trades(symbol, since, limit, params)
return self.build_ohlcv(trades, timeframe, since, limit)
def fetchOHLCV(self, symbol, timeframe='1m', since=None, limit=None, params={}):
return self.fetch_ohlcv(symbol, timeframe, since, limit, params)
def convert_trading_view_to_ohlcv(self, ohlcvs):
result = []
for i in range(0, len(ohlcvs['t'])):
result.append([
ohlcvs['t'][i] * 1000,
ohlcvs['o'][i],
ohlcvs['h'][i],
ohlcvs['l'][i],
ohlcvs['c'][i],
ohlcvs['v'][i],
])
return result
def convert_ohlcv_to_trading_view(self, ohlcvs):
result = {
't': [],
'o': [],
'h': [],
'l': [],
'c': [],
'v': [],
}
for i in range(0, len(ohlcvs)):
result['t'].append(int(ohlcvs[i][0] / 1000))
result['o'].append(ohlcvs[i][1])
result['h'].append(ohlcvs[i][2])
result['l'].append(ohlcvs[i][3])
result['c'].append(ohlcvs[i][4])
result['v'].append(ohlcvs[i][5])
return result
def build_ohlcv(self, trades, timeframe='1m', since=None, limit=None):
ms = self.parse_timeframe(timeframe) * 1000
ohlcvs = []
(high, low, close, volume) = (2, 3, 4, 5)
num_trades = len(trades)
oldest = (num_trades - 1) if limit is None else min(num_trades - 1, limit)
for i in range(0, oldest):
trade = trades[i]
if (since is not None) and (trade['timestamp'] < since):
continue
opening_time = int(math.floor(trade['timestamp'] / ms) * ms) # Shift the edge of the m/h/d (but not M)
j = len(ohlcvs)
if (j == 0) or opening_time >= ohlcvs[j - 1][0] + ms:
# moved to a new timeframe -> create a new candle from opening trade
ohlcvs.append([
opening_time,
trade['price'],
trade['price'],
trade['price'],
trade['price'],
trade['amount'],
])
else:
# still processing the same timeframe -> update opening trade
ohlcvs[j - 1][high] = max(ohlcvs[j - 1][high], trade['price'])
ohlcvs[j - 1][low] = min(ohlcvs[j - 1][low], trade['price'])
ohlcvs[j - 1][close] = trade['price']
ohlcvs[j - 1][volume] += trade['amount']
return ohlcvs
def parse_timeframe(self, timeframe):
amount = int(timeframe[0:-1])
unit = timeframe[-1]
if 'y' in unit:
scale = 60 * 60 * 24 * 365
elif 'M' in unit:
scale = 60 * 60 * 24 * 30
elif 'w' in unit:
scale = 60 * 60 * 24 * 7
elif 'd' in unit:
scale = 60 * 60 * 24
elif 'h' in unit:
scale = 60 * 60
else:
scale = 60 # 1m by default
return amount * scale
def parse_trades(self, trades, market=None, since=None, limit=None):
array = self.to_array(trades)
array = [self.parse_trade(trade, market) for trade in array]
array = self.sort_by(array, 'timestamp')
symbol = market['symbol'] if market else None
return self.filter_by_symbol_since_limit(array, symbol, since, limit)
def parse_transactions(self, transactions, currency=None, since=None, limit=None):
array = self.to_array(transactions)
array = [self.parse_transaction(transaction, currency) for transaction in array]
array = self.sort_by(array, 'timestamp')
code = currency['code'] if currency else None
return self.filter_by_currency_since_limit(array, code, since, limit)
def parse_orders(self, orders, market=None, since=None, limit=None):
array = self.to_array(orders)
array = [self.parse_order(order, market) for order in array]
array = self.sort_by(array, 'timestamp')
symbol = market['symbol'] if market else None
return self.filter_by_symbol_since_limit(array, symbol, since, limit)
def filter_by_value_since_limit(self, array, field, value=None, since=None, limit=None):
array = self.to_array(array)
if value:
array = [entry for entry in array if entry[field] == value]
if since:
array = [entry for entry in array if entry['timestamp'] >= since]
if limit:
array = array[0:limit]
return array
def filter_by_symbol_since_limit(self, array, symbol=None, since=None, limit=None):
return self.filter_by_value_since_limit(array, 'symbol', symbol, since, limit)
def filter_by_currency_since_limit(self, array, code=None, since=None, limit=None):
return self.filter_by_value_since_limit(array, 'currency', code, since, limit)
def filter_by_since_limit(self, array, since=None, limit=None):
array = self.to_array(array)
if since:
array = [entry for entry in array if entry['timestamp'] >= since]
if limit:
array = array[0:limit]
return array
def filter_by_symbol(self, array, symbol=None):
array = self.to_array(array)
if symbol:
return [entry for entry in array if entry['symbol'] == symbol]
return array
def filter_by_array(self, objects, key, values=None, indexed=True):
objects = self.to_array(objects)
# return all of them if no values were passed in
if values is None:
return self.index_by(objects, key) if indexed else objects
result = []
for i in range(0, len(objects)):
value = objects[i][key] if key in objects[i] else None
if value in values:
result.append(objects[i])
return self.index_by(result, key) if indexed else result
def currency(self, code):
if not self.currencies:
self.raise_error(ExchangeError, details='Currencies not loaded')
if isinstance(code, basestring) and (code in self.currencies):
return self.currencies[code]
self.raise_error(ExchangeError, details='Does not have currency code ' + str(code))
def find_market(self, string):
if not self.markets:
self.raise_error(ExchangeError, details='Markets not loaded')
if isinstance(string, basestring):
if string in self.markets_by_id:
return self.markets_by_id[string]
if string in self.markets:
return self.markets[string]
return string
def find_symbol(self, string, market=None):
if market is None:
market = self.find_market(string)
if isinstance(market, dict):
return market['symbol']
return string
def market(self, symbol):
if not self.markets:
self.raise_error(ExchangeError, details='Markets not loaded')
if isinstance(symbol, basestring) and (symbol in self.markets):
return self.markets[symbol]
self.raise_error(ExchangeError, details='No market symbol ' + str(symbol))
def market_ids(self, symbols):
return [self.market_id(symbol) for symbol in symbols]
def market_id(self, symbol):
market = self.market(symbol)
return market['id'] if type(market) is dict else symbol
def calculate_fee(self, symbol, type, side, amount, price, takerOrMaker='taker', params={}):
market = self.markets[symbol]
rate = market[takerOrMaker]
cost = float(self.cost_to_precision(symbol, amount * price))
return {
'rate': rate,
'type': takerOrMaker,
'currency': market['quote'],
'cost': float(self.fee_to_precision(symbol, rate * cost)),
}
def edit_limit_buy_order(self, id, symbol, *args):
return self.edit_limit_order(id, symbol, 'buy', *args)
def edit_limit_sell_order(self, id, symbol, *args):
return self.edit_limit_order(id, symbol, 'sell', *args)
def edit_limit_order(self, id, symbol, *args):
return self.edit_order(id, symbol, 'limit', *args)
def edit_order(self, id, symbol, *args):
if not self.enableRateLimit:
self.raise_error(ExchangeError, details='edit_order() requires enableRateLimit = true')
self.cancel_order(id, symbol)
return self.create_order(symbol, *args)
def create_limit_order(self, symbol, *args):
return self.create_order(symbol, 'limit', *args)
def create_market_order(self, symbol, *args):
return self.create_order(symbol, 'market', *args)
def create_limit_buy_order(self, symbol, *args):
return self.create_order(symbol, 'limit', 'buy', *args)
def create_limit_sell_order(self, symbol, *args):
return self.create_order(symbol, 'limit', 'sell', *args)
def create_market_buy_order(self, symbol, amount, params={}):
return self.create_order(symbol, 'market', 'buy', amount, None, params)
def create_market_sell_order(self, symbol, amount, params={}):
return self.create_order(symbol, 'market', 'sell', amount, None, params)
def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
raise NotSupported(self.id + ' sign() pure method must be redefined in derived classes')
# -------------------------------------------------------------------------
# web3 / 0x methods
def decryptAccountFromJSON(self, value, password):
return self.decryptAccount(json.loads(value) if isinstance(value, basestring) else value, password)
def decryptAccount(self, key, password):
return self.web3.eth.accounts.decrypt(key, password)
def decryptAccountFromPrivateKey(self, privateKey):
return self.web3.eth.accounts.privateKeyToAccount(privateKey)
def soliditySha3(self, array):
values = self.solidityValues(array)
types = self.solidityTypes(values)
return self.web3.soliditySha3(types, values).hex()
def soliditySha256(self, values):
types = self.solidityTypes(values)
solidity_values = self.solidityValues(values)
encoded_values = [hex_encode_abi_type(abi_type, value)[2:] for abi_type, value in zip(types, solidity_values)]
hex_string = '0x' + ''.join(encoded_values)
return '0x' + self.hash(self.encode(self.web3.toText(hex_string)), 'sha256')
def solidityTypes(self, array):
return ['address' if self.web3.isAddress(value) else 'uint256' for value in array]
def solidityValues(self, array):
return [self.web3.toChecksumAddress(value) if self.web3.isAddress(value) else int(value) for value in array]
def getZeroExOrderHash2(self, order):
return self.soliditySha3([
order['exchangeContractAddress'], # address
order['maker'], # address
order['taker'], # address
order['makerTokenAddress'], # address
order['takerTokenAddress'], # address
order['feeRecipient'], # address
order['makerTokenAmount'], # uint256
order['takerTokenAmount'], # uint256
order['makerFee'], # uint256
order['takerFee'], # uint256
order['expirationUnixTimestampSec'], # uint256
order['salt'], # uint256
])
def getZeroExOrderHash(self, order):
unpacked = [
self.web3.toChecksumAddress(order['exchangeContractAddress']), # { value: order.exchangeContractAddress, type: types_1.SolidityTypes.Address },
self.web3.toChecksumAddress(order['maker']), # { value: order.maker, type: types_1.SolidityTypes.Address },
self.web3.toChecksumAddress(order['taker']), # { value: order.taker, type: types_1.SolidityTypes.Address },
self.web3.toChecksumAddress(order['makerTokenAddress']), # { value: order.makerTokenAddress, type: types_1.SolidityTypes.Address },
self.web3.toChecksumAddress(order['takerTokenAddress']), # { value: order.takerTokenAddress, type: types_1.SolidityTypes.Address },
self.web3.toChecksumAddress(order['feeRecipient']), # { value: order.feeRecipient, type: types_1.SolidityTypes.Address },
int(order['makerTokenAmount']), # { value: bigNumberToBN(order.makerTokenAmount), type: types_1.SolidityTypes.Uint256, },
int(order['takerTokenAmount']), # { value: bigNumberToBN(order.takerTokenAmount), type: types_1.SolidityTypes.Uint256, },
int(order['makerFee']), # { value: bigNumberToBN(order.makerFee), type: types_1.SolidityTypes.Uint256, },
int(order['takerFee']), # { value: bigNumberToBN(order.takerFee), type: types_1.SolidityTypes.Uint256, },
int(order['expirationUnixTimestampSec']), # { value: bigNumberToBN(order.expirationUnixTimestampSec), type: types_1.SolidityTypes.Uint256, },
int(order['salt']), # { value: bigNumberToBN(order.salt), type: types_1.SolidityTypes.Uint256 },
]
types = [
'address', # { value: order.exchangeContractAddress, type: types_1.SolidityTypes.Address },
'address', # { value: order.maker, type: types_1.SolidityTypes.Address },
'address', # { value: order.taker, type: types_1.SolidityTypes.Address },
'address', # { value: order.makerTokenAddress, type: types_1.SolidityTypes.Address },
'address', # { value: order.takerTokenAddress, type: types_1.SolidityTypes.Address },
'address', # { value: order.feeRecipient, type: types_1.SolidityTypes.Address },
'uint256', # { value: bigNumberToBN(order.makerTokenAmount), type: types_1.SolidityTypes.Uint256, },
'uint256', # { value: bigNumberToBN(order.takerTokenAmount), type: types_1.SolidityTypes.Uint256, },
'uint256', # { value: bigNumberToBN(order.makerFee), type: types_1.SolidityTypes.Uint256, },
'uint256', # { value: bigNumberToBN(order.takerFee), type: types_1.SolidityTypes.Uint256, },
'uint256', # { value: bigNumberToBN(order.expirationUnixTimestampSec), type: types_1.SolidityTypes.Uint256, },
'uint256', # { value: bigNumberToBN(order.salt), type: types_1.SolidityTypes.Uint256 },
]
return self.web3.soliditySha3(types, unpacked).hex()
def signZeroExOrder(self, order):
orderHash = self.getZeroExOrderHash(order)
signature = self.signMessage(orderHash[-64:], self.privateKey)
return self.extend(order, {
'orderHash': orderHash,
'ecSignature': signature, # todo fix v if needed
})
def hashMessage(self, message):
message_bytes = bytes.fromhex(message)
return self.web3.sha3(b"\x19Ethereum Signed Message:\n" + str(len(message_bytes)).encode() + message_bytes).hex()
def signHash(self, hash, privateKey):
signature = self.web3.eth.account.signHash(hash[-64:], private_key=privateKey[-64:])
return {
'v': signature.v, # integer
'r': self.web3.toHex(signature.r), # '0x'-prefixed hex string
's': self.web3.toHex(signature.s), # '0x'-prefixed hex string
}
def signMessage(self, message, privateKey):
#
# The following comment is related to MetaMask, we use the upper type of signature prefix:
#
# z.ecSignOrderHashAsync ('0xcfdb0a485324ff37699b4c8557f6858f25916fc6fce5993b32fe018aea510b9f',
# '0x731fc101bbe102221c91c31ed0489f1ddfc439a3', {
# prefixType: 'ETH_SIGN',
# shouldAddPrefixBeforeCallingEthSign: true
# }).then ((e, r) => console.log (e,r))
#
# { ↓
# v: 28,
# r: "0xea7a68268b47c48d5d7a4c900e6f9af0015bf70951b3db2f1d835c5d544aaec2",
# s: "0x5d1db2a060c955c1fde4c967237b995c2361097405407b33c6046c8aeb3ccbdf"
# }
#
# --------------------------------------------------------------------
#
# z.ecSignOrderHashAsync ('0xcfdb0a485324ff37699b4c8557f6858f25916fc6fce5993b32fe018aea510b9f',
# '0x731fc101bbe102221c91c31ed0489f1ddfc439a3', {
# prefixType: 'NONE',
# shouldAddPrefixBeforeCallingEthSign: true
# }).then ((e, r) => console.log (e,r))
#
# { ↓
# v: 27,
# r: "0xc8c710022c57de4f529d448e9b40517dd9bfb49ff1eb245f5856664b865d14a6",
# s: "0x0740bb21f4f094fbbdbafa903bb8f057f82e0c6e4fe65d19a1daed4ed97cd394"
# }
#
message_hash = self.hashMessage(message)
signature = self.signHash(message_hash[-64:], privateKey[-64:])
return signature
| 40.16282 | 185 | 0.600177 | [
"MIT"
] | tssujt/ccxt | python/ccxt/base/exchange.py | 64,385 | Python |
from pydub import AudioSegment
from pydub.playback import play
import os
import utils
class audiofile:
def __init__(self, file):
""" Init audio stream """
self.file = file
def play(self):
""" Play entire file """
utils.displayInfoMessage('Playing Audio')
pathparts = self.file.rsplit(".", 1)
fileformat = pathparts[1]
song = AudioSegment.from_file(self.file, format=fileformat)
play(song)
utils.displayInfoMessage('')
utils.displayErrorMessage('')
def length(self):
pathparts = self.file.rsplit(".", 1)
fileformat = pathparts[1]
song = AudioSegment.from_file(self.file, format=fileformat)
return song.duration_seconds | 25.965517 | 67 | 0.628154 | [
"MIT"
] | CoryXie/SpeechShadowing | AudioFile.py | 753 | Python |
"""Tasmota MQTT."""
import asyncio
import logging
from typing import Union
import attr
from .const import COMMAND_BACKLOG
DEBOUNCE_TIMEOUT = 1
_LOGGER = logging.getLogger(__name__)
class Timer:
"""Simple timer."""
def __init__(self, timeout, callback):
self._timeout = timeout
self._callback = callback
self._task = asyncio.ensure_future(self._job())
async def _job(self):
await asyncio.sleep(self._timeout)
self._callback()
def cancel(self):
"""Cancel the timer."""
self._task.cancel()
PublishPayloadType = Union[str, bytes, int, float, None]
@attr.s(slots=True, frozen=True)
class Message:
"""MQTT Message."""
topic: str = attr.ib()
payload: PublishPayloadType = attr.ib()
qos: int = attr.ib()
retain: bool = attr.ib()
class TasmotaMQTTClient:
"""Helper class to sue an external MQTT client."""
def __init__(self, publish, subscribe, unsubscribe):
"""Initialize."""
self._pending_messages = {}
self._publish = publish
self._subscribe = subscribe
self._unsubscribe = unsubscribe
def publish(self, *args, **kwds):
"""Publish a message."""
return self._publish(*args, **kwds)
def publish_debounced(self, topic, payload, qos=None, retain=None):
"""Publish a message, with debounce."""
msg = Message(topic, payload, qos, retain)
def publish_callback():
_LOGGER.debug("publish_debounced: publishing %s", msg)
self._pending_messages.pop(msg)
self.publish(msg.topic, msg.payload, qos=msg.qos, retain=msg.retain)
if msg in self._pending_messages:
timer = self._pending_messages.pop(msg)
timer.cancel()
timer = Timer(DEBOUNCE_TIMEOUT, publish_callback)
self._pending_messages[msg] = timer
async def subscribe(self, sub_state, topics):
"""Subscribe to topics."""
return await self._subscribe(sub_state, topics)
async def unsubscribe(self, sub_state):
"""Unsubscribe from topics."""
return await self._unsubscribe(sub_state)
def send_commands(mqtt_client, command_topic, commands):
"""Send a sequence of commands."""
backlog_topic = command_topic + COMMAND_BACKLOG
backlog = ";".join(["NoDelay;%s %s" % command for command in commands])
mqtt_client.publish(backlog_topic, backlog)
| 27.545455 | 80 | 0.64934 | [
"MIT"
] | ascillato/hatasmota | hatasmota/mqtt.py | 2,424 | Python |
import os
from glyphsLib import GSFont
import pytest
from fontbakery.codetesting import (
assert_PASS,
assert_results_contain,
assert_SKIP,
GLYPHSAPP_TEST_FILE,
PATH_TEST_DATA,
portable_path,
TEST_FILE,
)
from fontbakery.message import Message
from fontbakery.status import PASS, FAIL, WARN, ERROR, INFO, SKIP, DEBUG
def test_portable_path():
test_path = "dir/subdir/file"
assert portable_path(test_path) == f"{os.sep}".join(test_path.split("/"))
def test_TEST_FILE():
file_path = "dir/file"
assert TEST_FILE(file_path) == f"{PATH_TEST_DATA}{file_path}"
def test_GLYPHSAPP_TEST_FILE():
glyphs_filename = "Comfortaa.glyphs"
gfile = GLYPHSAPP_TEST_FILE(glyphs_filename)
assert isinstance(gfile, GSFont)
def test_assert_SKIP_success(capsys):
skip_msg = "SKIP message"
skip_reason = "SKIP reason"
results = [
(PASS,),
(SKIP, skip_msg),
]
assert assert_SKIP(results, skip_reason) == skip_msg
captured = capsys.readouterr()
assert captured.out == f"Test SKIP {skip_reason}\n"
def test_assert_SKIP_failure(capsys):
pass_msg = "PASS message"
skip_reason = "SKIP reason"
results = [
(SKIP,),
(PASS, pass_msg),
]
with pytest.raises(AssertionError):
assert_SKIP(results, skip_reason)
captured = capsys.readouterr()
assert captured.out == f"Test SKIP {skip_reason}\n"
def test_assert_PASS_success(capsys):
pass_msg = "PASS message"
pass_reason = "with a good font..."
results = [
(SKIP,),
(PASS, pass_msg),
]
assert assert_PASS(results) == pass_msg
captured = capsys.readouterr()
assert captured.out == f"Test PASS {pass_reason}\n"
def test_assert_PASS_failure(capsys):
skip_msg = "SKIP message"
pass_reason = "with a good font..."
results = [
(PASS,),
(SKIP, skip_msg),
]
with pytest.raises(AssertionError):
assert_PASS(results)
captured = capsys.readouterr()
assert captured.out == f"Test PASS {pass_reason}\n"
def test_assert_PASS_ignore_error_true(capsys):
error_msg = "ERROR message"
pass_reason = "with a good font..."
ignore = "an error"
results = [
(PASS,),
(ERROR, error_msg),
]
assert assert_PASS(results, ignore_error=ignore) is None
captured = capsys.readouterr()
assert captured.out == f"Test PASS {pass_reason}\n{ignore}\n"
def test_assert_PASS_ignore_error_false(capsys):
error_msg = "ERROR message"
pass_reason = "with a good font..."
results = [
(PASS,),
(ERROR, error_msg),
]
with pytest.raises(AssertionError):
assert_PASS(results)
captured = capsys.readouterr()
assert captured.out == f"Test PASS {pass_reason}\n"
def test_assert_results_contain_expected_msgcode_string():
bogus_msgcode = True
with pytest.raises(Exception) as err:
assert_results_contain([], PASS, bogus_msgcode)
assert str(err.value) == "The expected message code must be a string"
def test_assert_results_contain_ignore_error_true(capsys):
msg_code = "a message code"
ignore = "an error"
expected_status = PASS
results = [
(ERROR, ""),
(FAIL, ""),
]
assert (
assert_results_contain(results, expected_status, msg_code, ignore_error=ignore)
is None
)
captured = capsys.readouterr()
assert captured.out == f"Test {expected_status} [{msg_code}]\n{ignore}\n"
def test_assert_results_contain_bare_string(capsys):
msg_code = "a message code"
bare_str = "just a string"
reason = "just because..."
expected_status = PASS
results = [
(WARN, bare_str),
(INFO, bare_str),
]
with pytest.raises(Exception) as err:
assert_results_contain(results, expected_status, msg_code, reason)
assert f"(Bare string: {bare_str!r})" in str(err.value)
captured = capsys.readouterr()
assert captured.out == f"Test {expected_status} {reason}\n"
def test_assert_results_contain_success_string_msg(capsys):
msg_code = "a message code"
expected_status = PASS
results = [
(PASS, msg_code),
]
assert assert_results_contain(results, expected_status, msg_code) == msg_code
captured = capsys.readouterr()
assert captured.out == f"Test {expected_status} [{msg_code}]\n"
def test_assert_results_contain_failure_string_msg(capsys):
msg_code = "a message code"
expected_status = PASS
results = [
(DEBUG, msg_code),
]
exception_message = (
f"Expected to find {expected_status}, [code: {msg_code}]\n"
f"But did not find it in:\n"
f"{results}"
)
with pytest.raises(Exception) as err:
assert_results_contain(results, expected_status, msg_code)
assert str(err.value) == exception_message
captured = capsys.readouterr()
assert captured.out == f"Test {expected_status} [{msg_code}]\n"
def test_assert_results_contain_success_message_msg(capsys):
msg_code = "a message code"
msg_human = "human readable message"
message = Message(msg_code, msg_human)
expected_status = FAIL
results = [
(FAIL, message),
]
assert assert_results_contain(results, expected_status, msg_code) == msg_human
captured = capsys.readouterr()
assert captured.out == f"Test {expected_status} [{msg_code}]\n"
def test_assert_results_contain_failure_message_msg(capsys):
msg_code = "a message code"
msg_human = "human readable message"
message = Message(msg_code, msg_human)
expected_status = FAIL
results = [
(ERROR, message),
]
exception_message = (
f"Expected to find {expected_status}, [code: {msg_code}]\n"
f"But did not find it in:\n"
f"{results}"
)
with pytest.raises(Exception) as err:
assert_results_contain(results, expected_status, msg_code)
assert str(err.value) == exception_message
captured = capsys.readouterr()
assert captured.out == f"Test {expected_status} [{msg_code}]\n"
| 27.151786 | 87 | 0.66853 | [
"Apache-2.0"
] | paullinnerud/fontbakery | tests/test_codetesting.py | 6,082 | Python |
from gym_multigrid.multigrid import *
class CollectGameEnv(MultiGridEnv):
"""
Environment in which the agents have to collect the balls
"""
def __init__(
self,
size=10,
width=None,
height=None,
num_balls=[],
agents_index = [],
balls_index=[],
balls_reward=[],
zero_sum = False,
view_size=7
):
self.num_balls = num_balls
self.balls_index = balls_index
self.balls_reward = balls_reward
self.zero_sum = zero_sum
self.world = World
agents = []
for i in agents_index:
agents.append(Agent(self.world, i, view_size=view_size))
super().__init__(
grid_size=size,
width=width,
height=height,
max_steps= 10000,
# Set this to True for maximum speed
see_through_walls=False,
agents=agents,
agent_view_size=view_size
)
def _gen_grid(self, width, height):
self.grid = Grid(width, height)
# Generate the surrounding walls
self.grid.horz_wall(self.world, 0, 0)
self.grid.horz_wall(self.world, 0, height-1)
self.grid.vert_wall(self.world, 0, 0)
self.grid.vert_wall(self.world, width-1, 0)
for number, index, reward in zip(self.num_balls, self.balls_index, self.balls_reward):
for i in range(number):
self.place_obj(Ball(self.world, index, reward))
# Randomize the player start position and orientation
for a in self.agents:
self.place_agent(a)
def _reward(self, i, rewards, reward=1):
"""
Compute the reward to be given upon success
"""
for j,a in enumerate(self.agents):
if a.index==i or a.index==0:
rewards[j]+=reward
if self.zero_sum:
if a.index!=i or a.index==0:
rewards[j] -= reward
def _handle_pickup(self, i, rewards, fwd_pos, fwd_cell):
if fwd_cell:
if fwd_cell.can_pickup():
if fwd_cell.index in [0, self.agents[i].index]:
fwd_cell.cur_pos = np.array([-1, -1])
self.grid.set(*fwd_pos, None)
self._reward(i, rewards, fwd_cell.reward)
def _handle_drop(self, i, rewards, fwd_pos, fwd_cell):
pass
def step(self, actions):
obs, rewards, done, info = MultiGridEnv.step(self, actions)
return obs, rewards, done, info
class CollectGame4HEnv10x10N2(CollectGameEnv):
def __init__(self):
super().__init__(size=10,
num_balls=[5],
agents_index = [1,2,3],
balls_index=[0],
balls_reward=[1],
zero_sum=True)
| 28.232323 | 94 | 0.562433 | [
"Apache-2.0"
] | ArnaudFickinger/gym-multigrid | gym_multigrid/envs/collect_game.py | 2,795 | Python |
# ble_command_load_group.py/Open GoPro, Version 2.0 (C) Copyright 2021 GoPro, Inc. (http://gopro.com/OpenGoPro).
# This copyright was auto-generated on Wed, Sep 1, 2021 5:05:57 PM
import sys
import asyncio
import logging
import argparse
from typing import Optional
from binascii import hexlify
from bleak import BleakClient
from tutorial_modules import GOPRO_BASE_UUID, connect_ble
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()
async def main(identifier: Optional[str]) -> None:
# Synchronization event to wait until notification response is received
event = asyncio.Event()
# UUIDs to write to and receive responses from
COMMAND_REQ_UUID = GOPRO_BASE_UUID.format("0072")
COMMAND_RSP_UUID = GOPRO_BASE_UUID.format("0073")
response_uuid = COMMAND_RSP_UUID
client: BleakClient
def notification_handler(handle: int, data: bytes) -> None:
logger.info(f'Received response at {handle=}: {hexlify(data, ":")!r}')
# If this is the correct handle and the status is success, the command was a success
if client.services.characteristics[handle].uuid == response_uuid and data[2] == 0x00:
logger.info("Command sent successfully")
# Anything else is unexpected. This shouldn't happen
else:
logger.error("Unexpected response")
# Notify the writer
event.set()
client = await connect_ble(notification_handler, identifier)
# Write to command request BleUUID to load the video preset group
logger.info("Loading the video preset group...")
event.clear()
await client.write_gatt_char(COMMAND_REQ_UUID, bytearray([0x04, 0x3E, 0x02, 0x03, 0xE8]))
await event.wait() # Wait to receive the notification response
await client.disconnect()
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Connect to a GoPro camera, then change the Preset Group to Video."
)
parser.add_argument(
"-i",
"--identifier",
type=str,
help="Last 4 digits of GoPro serial number, which is the last 4 digits of the default camera SSID. If not used, first discovered GoPro will be connected to",
default=None,
)
args = parser.parse_args()
try:
asyncio.run(main(args.identifier))
except:
sys.exit(-1)
else:
sys.exit(0)
| 33 | 165 | 0.694444 | [
"MIT"
] | JKlingPhotos/OpenGoPro | demos/python/tutorial/tutorial_modules/tutorial_2_send_ble_commands/ble_command_load_group.py | 2,376 | Python |
import inspect
from collections import OrderedDict
from json.decoder import JSONDecodeError
from typing import Optional, Tuple, Union
from urllib.parse import urljoin
import requests
from bs4 import BeautifulSoup
from recipe_scrapers.settings import settings
from ._schemaorg import SchemaOrg
# some sites close their content for 'bots', so user-agent must be supplied
HEADERS = {
"User-Agent": "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.7) Gecko/2009021910 Firefox/3.0.7"
}
class AbstractScraper:
def __init__(
self,
url,
proxies: Optional[str] = None, # allows us to specify optional proxy server
timeout: Optional[
Union[float, Tuple, None]
] = None, # allows us to specify optional timeout for request
):
if settings.TEST_MODE: # when testing, we load a file
page_data = url.read()
url = "https://test.example.com/"
else:
page_data = requests.get(
url, headers=HEADERS, proxies=proxies, timeout=timeout
).content
self.soup = BeautifulSoup(page_data, "html.parser")
self.url = url
# Attempt to read Schema.org data. Gracefully fail if it raises an exception parsing the JSON.
# The scraper subclass can use BeautifulSoup to extract the information.
try:
self.schema = SchemaOrg(page_data)
except JSONDecodeError:
pass
# attach the plugins as instructed in settings.PLUGINS
for name, func in inspect.getmembers(self, inspect.ismethod):
current_method = getattr(self.__class__, name)
for plugin in reversed(settings.PLUGINS):
if plugin.should_run(self.host(), name):
current_method = plugin.run(current_method)
setattr(self.__class__, name, current_method)
@classmethod
def host(cls) -> str:
""" get the host of the url, so we can use the correct scraper """
raise NotImplementedError("This should be implemented.")
def canonical_url(self):
canonical_link = self.soup.find("link", {"rel": "canonical", "href": True})
if canonical_link:
return urljoin(self.url, canonical_link["href"])
return self.url
def title(self):
raise NotImplementedError("This should be implemented.")
def total_time(self):
""" total time it takes to preparate the recipe in minutes """
raise NotImplementedError("This should be implemented.")
def yields(self):
""" The number of servings or items in the recipe """
raise NotImplementedError("This should be implemented.")
def image(self):
raise NotImplementedError("This should be implemented.")
def nutrients(self):
raise NotImplementedError("This should be implemented.")
def language(self):
"""
Human language the recipe is written in.
May be overridden by individual scrapers.
"""
candidate_languages = OrderedDict()
html = self.soup.find("html", {"lang": True})
candidate_languages[html.get("lang")] = True
# Deprecated: check for a meta http-equiv header
# See: https://www.w3.org/International/questions/qa-http-and-lang
meta_language = (
self.soup.find(
"meta",
{
"http-equiv": lambda x: x and x.lower() == "content-language",
"content": True,
},
)
if settings.META_HTTP_EQUIV
else None
)
if meta_language:
language = meta_language.get("content").split(",", 1)[0]
if language:
candidate_languages[language] = True
# If other langs exist, remove 'en' commonly generated by HTML editors
if len(candidate_languages) > 1:
candidate_languages.pop("en", None)
# Return the first candidate language
return candidate_languages.popitem(last=False)[0]
def ingredients(self):
raise NotImplementedError("This should be implemented.")
def instructions(self):
raise NotImplementedError("This should be implemented.")
def ratings(self):
raise NotImplementedError("This should be implemented.")
def author(self):
raise NotImplementedError("This should be implemented.")
def reviews(self):
raise NotImplementedError("This should be implemented.")
def links(self):
invalid_href = {"#", ""}
links_html = self.soup.findAll("a", href=True)
return [link.attrs for link in links_html if link["href"] not in invalid_href]
def site_name(self):
meta = self.soup.find("meta", property="og:site_name")
return meta.get("content") if meta else None
| 34.302817 | 110 | 0.625539 | [
"MIT"
] | AlexRogalskiy/recipe-scrapers | recipe_scrapers/_abstract.py | 4,871 | Python |
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
# pylint: disable=unused-import,g-bad-import-order
"""## Activation Functions
The activation ops provide different types of nonlinearities for use in neural
networks. These include smooth nonlinearities (`sigmoid`, `tanh`, `elu`,
`softplus`, and `softsign`), continuous but not everywhere differentiable
functions (`relu`, `relu6`, and `relu_x`), and random regularization
(`dropout`).
All activation ops apply componentwise, and produce a tensor of the same
shape as the input tensor.
@@relu
@@relu6
@@elu
@@softplus
@@softsign
@@dropout
@@bias_add
@@sigmoid
@@tanh
## Convolution
The convolution ops sweep a 2-D filter over a batch of images, applying the
filter to each window of each image of the appropriate size. The different
ops trade off between generic vs. specific filters:
* `conv2d`: Arbitrary filters that can mix channels together.
* `depthwise_conv2d`: Filters that operate on each channel independently.
* `separable_conv2d`: A depthwise spatial filter followed by a pointwise filter.
Note that although these ops are called "convolution", they are strictly
speaking "cross-correlation" since the filter is combined with an input window
without reversing the filter. For details, see [the properties of
cross-correlation](https://en.wikipedia.org/wiki/Cross-correlation#Properties).
The filter is applied to image patches of the same size as the filter and
strided according to the `strides` argument. `strides = [1, 1, 1, 1]` applies
the filter to a patch at every offset, `strides = [1, 2, 2, 1]` applies the
filter to every other image patch in each dimension, etc.
Ignoring channels for the moment, and assume that the 4-D `input` has shape
`[batch, in_height, in_width, ...]` and the 4-D `filter` has shape
`[filter_height, filter_width, ...]`, then the spatial semantics of the
convolution ops are as follows: first, according to the padding scheme chosen
as `'SAME'` or `'VALID'`, the output size and the padding pixels are computed.
For the `'SAME'` padding, the output height and width are computed as:
out_height = ceil(float(in_height) / float(strides[1]))
out_width = ceil(float(in_width) / float(strides[2]))
and the padding on the top and left are computed as:
pad_along_height = ((out_height - 1) * strides[1] +
filter_height - in_height)
pad_along_width = ((out_width - 1) * strides[2] +
filter_width - in_width)
pad_top = pad_along_height / 2
pad_left = pad_along_width / 2
Note that the division by 2 means that there might be cases when the padding on
both sides (top vs bottom, right vs left) are off by one. In this case, the
bottom and right sides always get the one additional padded pixel. For example,
when `pad_along_height` is 5, we pad 2 pixels at the top and 3 pixels at the
bottom. Note that this is different from existing libraries such as cuDNN and
Caffe, which explicitly specify the number of padded pixels and always pad the
same number of pixels on both sides.
For the `'VALID`' padding, the output height and width are computed as:
out_height = ceil(float(in_height - filter_height + 1) / float(strides[1]))
out_width = ceil(float(in_width - filter_width + 1) / float(strides[2]))
and the padding values are always zero. The output is then computed as
output[b, i, j, :] =
sum_{di, dj} input[b, strides[1] * i + di - pad_top,
strides[2] * j + dj - pad_left, ...] *
filter[di, dj, ...]
where any value outside the original input image region are considered zero (
i.e. we pad zero values around the border of the image).
Since `input` is 4-D, each `input[b, i, j, :]` is a vector. For `conv2d`, these
vectors are multiplied by the `filter[di, dj, :, :]` matrices to produce new
vectors. For `depthwise_conv_2d`, each scalar component `input[b, i, j, k]`
is multiplied by a vector `filter[di, dj, k]`, and all the vectors are
concatenated.
@@conv2d
@@depthwise_conv2d
@@separable_conv2d
@@atrous_conv2d
@@conv2d_transpose
@@conv3d
## Pooling
The pooling ops sweep a rectangular window over the input tensor, computing a
reduction operation for each window (average, max, or max with argmax). Each
pooling op uses rectangular windows of size `ksize` separated by offset
`strides`. For example, if `strides` is all ones every window is used, if
`strides` is all twos every other window is used in each dimension, etc.
In detail, the output is
output[i] = reduce(value[strides * i:strides * i + ksize])
where the indices also take into consideration the padding values. Please refer
to the `Convolution` section for details about the padding calculation.
@@avg_pool
@@max_pool
@@max_pool_with_argmax
@@avg_pool3d
@@max_pool3d
## Morphological filtering
Morphological operators are non-linear filters used in image processing.
[Greyscale morphological dilation]
(https://en.wikipedia.org/wiki/Dilation_(morphology)) is the max-sum counterpart
of standard sum-product convolution:
output[b, y, x, c] =
max_{dy, dx} input[b,
strides[1] * y + rates[1] * dy,
strides[2] * x + rates[2] * dx,
c] +
filter[dy, dx, c]
The `filter` is usually called structuring function. Max-pooling is a special
case of greyscale morphological dilation when the filter assumes all-zero
values (a.k.a. flat structuring function).
[Greyscale morphological erosion]
(https://en.wikipedia.org/wiki/Erosion_(morphology)) is the min-sum counterpart
of standard sum-product convolution:
output[b, y, x, c] =
min_{dy, dx} input[b,
strides[1] * y - rates[1] * dy,
strides[2] * x - rates[2] * dx,
c] -
filter[dy, dx, c]
Dilation and erosion are dual to each other. The dilation of the input signal
`f` by the structuring signal `g` is equal to the negation of the erosion of
`-f` by the reflected `g`, and vice versa.
Striding and padding is carried out in exactly the same way as in standard
convolution. Please refer to the `Convolution` section for details.
@@dilation2d
@@erosion2d
## Normalization
Normalization is useful to prevent neurons from saturating when inputs may
have varying scale, and to aid generalization.
@@l2_normalize
@@local_response_normalization
@@sufficient_statistics
@@normalize_moments
@@moments
## Losses
The loss ops measure error between two tensors, or between a tensor and zero.
These can be used for measuring accuracy of a network in a regression task
or for regularization purposes (weight decay).
@@l2_loss
## Classification
TensorFlow provides several operations that help you perform classification.
@@sigmoid_cross_entropy_with_logits
@@softmax
@@log_softmax
@@softmax_cross_entropy_with_logits
@@sparse_softmax_cross_entropy_with_logits
@@weighted_cross_entropy_with_logits
## Embeddings
TensorFlow provides library support for looking up values in embedding
tensors.
@@embedding_lookup
@@embedding_lookup_sparse
## Recurrent Neural Networks
TensorFlow provides a number of methods for constructing Recurrent
Neural Networks. Most accept an `RNNCell`-subclassed object
(see the documentation for `tf.nn.rnn_cell`).
@@dynamic_rnn
@@rnn
@@state_saving_rnn
@@bidirectional_rnn
## Conectionist Temporal Classification (CTC)
@@ctc_loss
@@ctc_greedy_decoder
@@ctc_beam_search_decoder
## Evaluation
The evaluation ops are useful for measuring the performance of a network.
Since they are nondifferentiable, they are typically used at evaluation time.
@@top_k
@@in_top_k
## Candidate Sampling
Do you want to train a multiclass or multilabel model with thousands
or millions of output classes (for example, a language model with a
large vocabulary)? Training with a full Softmax is slow in this case,
since all of the classes are evaluated for every training example.
Candidate Sampling training algorithms can speed up your step times by
only considering a small randomly-chosen subset of contrastive classes
(called candidates) for each batch of training examples.
See our [Candidate Sampling Algorithms Reference]
(../../extras/candidate_sampling.pdf)
### Sampled Loss Functions
TensorFlow provides the following sampled loss functions for faster training.
@@nce_loss
@@sampled_softmax_loss
### Candidate Samplers
TensorFlow provides the following samplers for randomly sampling candidate
classes when using one of the sampled loss functions above.
@@uniform_candidate_sampler
@@log_uniform_candidate_sampler
@@learned_unigram_candidate_sampler
@@fixed_unigram_candidate_sampler
### Miscellaneous candidate sampling utilities
@@compute_accidental_hits
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from six.moves import xrange # pylint: disable=redefined-builtin
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import candidate_sampling_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import embedding_ops
from tensorflow.python.ops import init_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import nn_grad
from tensorflow.python.ops import nn_ops
from tensorflow.python.ops import numerics
from tensorflow.python.ops import random_ops
from tensorflow.python.ops import rnn_cell
from tensorflow.python.ops import seq2seq
from tensorflow.python.ops import sparse_ops
from tensorflow.python.ops import variable_scope as vs
from tensorflow.python.ops.math_ops import sigmoid
from tensorflow.python.ops.math_ops import tanh
from tensorflow.python.util.all_util import make_all
# Bring more nn-associated functionality into this package.
# go/tf-wildcard-import
# pylint: disable=wildcard-import
from tensorflow.python.ops.ctc_ops import *
from tensorflow.python.ops.nn_ops import *
from tensorflow.python.ops.candidate_sampling_ops import *
from tensorflow.python.ops.embedding_ops import *
from tensorflow.python.ops.rnn import *
# pylint: enable=wildcard-import
def sigmoid_cross_entropy_with_logits(logits, targets, name=None):
"""Computes sigmoid cross entropy given `logits`.
Measures the probability error in discrete classification tasks in which each
class is independent and not mutually exclusive. For instance, one could
perform multilabel classification where a picture can contain both an elephant
and a dog at the same time.
For brevity, let `x = logits`, `z = targets`. The logistic loss is
z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
= z * -log(1 / (1 + exp(-x))) + (1 - z) * -log(exp(-x) / (1 + exp(-x)))
= z * log(1 + exp(-x)) + (1 - z) * (-log(exp(-x)) + log(1 + exp(-x)))
= z * log(1 + exp(-x)) + (1 - z) * (x + log(1 + exp(-x))
= (1 - z) * x + log(1 + exp(-x))
= x - x * z + log(1 + exp(-x))
For x < 0, to avoid overflow in exp(-x), we reformulate the above
x - x * z + log(1 + exp(-x))
= log(exp(x)) - x * z + log(1 + exp(-x))
= - x * z + log(1 + exp(x))
Hence, to ensure stability and avoid overflow, the implementation uses this
equivalent formulation
max(x, 0) - x * z + log(1 + exp(-abs(x)))
`logits` and `targets` must have the same type and shape.
Args:
logits: A `Tensor` of type `float32` or `float64`.
targets: A `Tensor` of the same type and shape as `logits`.
name: A name for the operation (optional).
Returns:
A `Tensor` of the same shape as `logits` with the componentwise
logistic losses.
Raises:
ValueError: If `logits` and `targets` do not have the same shape.
"""
with ops.op_scope([logits, targets], name, "logistic_loss") as name:
logits = ops.convert_to_tensor(logits, name="logits")
targets = ops.convert_to_tensor(targets, name="targets")
try:
targets.get_shape().merge_with(logits.get_shape())
except ValueError:
raise ValueError(
"logits and targets must have the same shape (%s vs %s)"
% (logits.get_shape(), targets.get_shape()))
# The logistic loss formula from above is
# x - x * z + log(1 + exp(-x))
# For x < 0, a more numerically stable formula is
# -x * z + log(1 + exp(x))
# Note that these two expressions can be combined into the following:
# max(x, 0) - x * z + log(1 + exp(-abs(x)))
# To allow computing gradients at zero, we define custom versions of max and
# abs functions.
zeros = array_ops.zeros_like(logits, dtype=logits.dtype)
cond = (logits >= zeros)
relu_logits = math_ops.select(cond, logits, zeros)
neg_abs_logits = math_ops.select(cond, -logits, logits)
return math_ops.add(relu_logits - logits * targets,
math_ops.log(1 + math_ops.exp(neg_abs_logits)),
name=name)
def weighted_cross_entropy_with_logits(logits, targets, pos_weight,
name=None):
"""Computes a weighted cross entropy.
This is like `sigmoid_cross_entropy_with_logits()` except that `pos_weight`,
allows one to trade off recall and precision by up- or down-weighting the
cost of a positive error relative to a negative error.
The usual cross-entropy cost is defined as:
targets * -log(sigmoid(logits)) + (1 - targets) * -log(1 - sigmoid(logits))
The argument `pos_weight` is used as a multiplier for the positive targets:
targets * -log(sigmoid(logits)) * pos_weight +
(1 - targets) * -log(1 - sigmoid(logits))
For brevity, let `x = logits`, `z = targets`, `q = pos_weight`.
The loss is:
qz * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
= qz * -log(1 / (1 + exp(-x))) + (1 - z) * -log(exp(-x) / (1 + exp(-x)))
= qz * log(1 + exp(-x)) + (1 - z) * (-log(exp(-x)) + log(1 + exp(-x)))
= qz * log(1 + exp(-x)) + (1 - z) * (x + log(1 + exp(-x))
= (1 - z) * x + (qz + 1 - z) * log(1 + exp(-x))
= (1 - z) * x + (1 + (q - 1) * z) * log(1 + exp(-x))
Setting `l = (1 + (q - 1) * z)`, to ensure stability and avoid overflow,
the implementation uses
(1 - z) * x + l * (log(1 + exp(-abs(x))) + max(-x, 0))
`logits` and `targets` must have the same type and shape.
Args:
logits: A `Tensor` of type `float32` or `float64`.
targets: A `Tensor` of the same type and shape as `logits`.
pos_weight: A coefficient to use on the positive examples.
name: A name for the operation (optional).
Returns:
A `Tensor` of the same shape as `logits` with the componentwise
weightedlogistic losses.
Raises:
ValueError: If `logits` and `targets` do not have the same shape.
"""
with ops.op_scope([logits, targets], name, "logistic_loss") as name:
logits = ops.convert_to_tensor(logits, name="logits")
targets = ops.convert_to_tensor(targets, name="targets")
try:
targets.get_shape().merge_with(logits.get_shape())
except ValueError:
raise ValueError(
"logits and targets must have the same shape (%s vs %s)"
% (logits.get_shape(), targets.get_shape()))
# The logistic loss formula from above is
# (1 - z) * x + (1 + (q - 1) * z) * log(1 + exp(-x))
# For x < 0, a more numerically stable formula is
# (1 - z) * x + (1 + (q - 1) * z) * log(1 + exp(x)) - l * x
# To avoid branching, we use the combined version
# (1 - z) * x + l * (log(1 + exp(-abs(x))) + max(-x, 0))
log_weight = 1 + (pos_weight - 1) * targets
return math_ops.add(
(1 - targets) * logits,
log_weight * (math_ops.log(1 + math_ops.exp(-math_ops.abs(logits))) +
nn_ops.relu(-logits)),
name=name)
def relu_layer(x, weights, biases, name=None):
"""Computes Relu(x * weight + biases).
Args:
x: a 2D tensor. Dimensions typically: batch, in_units
weights: a 2D tensor. Dimensions typically: in_units, out_units
biases: a 1D tensor. Dimensions: out_units
name: A name for the operation (optional). If not specified
"nn_relu_layer" is used.
Returns:
A 2-D Tensor computing relu(matmul(x, weights) + biases).
Dimensions typically: batch, out_units.
"""
with ops.op_scope([x, weights, biases], name, "relu_layer") as name:
x = ops.convert_to_tensor(x, name="x")
weights = ops.convert_to_tensor(weights, name="weights")
biases = ops.convert_to_tensor(biases, name="biases")
xw_plus_b = nn_ops.bias_add(math_ops.matmul(x, weights), biases)
return nn_ops.relu(xw_plus_b, name=name)
def l2_normalize(x, dim, epsilon=1e-12, name=None):
"""Normalizes along dimension `dim` using an L2 norm.
For a 1-D tensor with `dim = 0`, computes
output = x / sqrt(max(sum(x**2), epsilon))
For `x` with more dimensions, independently normalizes each 1-D slice along
dimension `dim`.
Args:
x: A `Tensor`.
dim: Dimension along which to normalize.
epsilon: A lower bound value for the norm. Will use `sqrt(epsilon)` as the
divisor if `norm < sqrt(epsilon)`.
name: A name for this operation (optional).
Returns:
A `Tensor` with the same shape as `x`.
"""
with ops.op_scope([x], name, "l2_normalize") as name:
x = ops.convert_to_tensor(x, name="x")
square_sum = math_ops.reduce_sum(math_ops.square(x), [dim], keep_dims=True)
x_inv_norm = math_ops.rsqrt(math_ops.maximum(square_sum, epsilon))
return math_ops.mul(x, x_inv_norm, name=name)
def zero_fraction(value, name=None):
"""Returns the fraction of zeros in `value`.
If `value` is empty, the result is `nan`.
This is useful in summaries to measure and report sparsity. For example,
z = tf.Relu(...)
summ = tf.scalar_summary('sparsity', tf.nn.zero_fraction(z))
Args:
value: A tensor of numeric type.
name: A name for the operation (optional).
Returns:
The fraction of zeros in `value`, with type `float32`.
"""
with ops.op_scope([value], name, "zero_fraction"):
value = ops.convert_to_tensor(value, name="value")
zero = constant_op.constant(0, dtype=value.dtype, name="zero")
return math_ops.reduce_mean(math_ops.cast(math_ops.equal(value, zero),
dtypes.float32))
def depthwise_conv2d(input, filter, strides, padding, name=None):
"""Depthwise 2-D convolution.
Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
and a filter tensor of shape
`[filter_height, filter_width, in_channels, channel_multiplier]`
containing `in_channels` convolutional filters of depth 1, `depthwise_conv2d`
applies a different filter to each input channel (expanding from 1 channel
to `channel_multiplier` channels for each), then concatenates the results
together. The output has `in_channels * channel_multiplier` channels.
In detail,
output[b, i, j, k * channel_multiplier + q] =
sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] *
filter[di, dj, k, q]
Must have `strides[0] = strides[3] = 1`. For the most common case of the
same horizontal and vertical strides, `strides = [1, stride, stride, 1]`.
Args:
input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
filter: 4-D with shape
`[filter_height, filter_width, in_channels, channel_multiplier]`.
strides: 1-D of size 4. The stride of the sliding window for each
dimension of `input`.
padding: A string, either `'VALID'` or `'SAME'`. The padding algorithm.
See the [comment here](https://www.tensorflow.org/api_docs/python/nn.html#convolution)
name: A name for this operation (optional).
Returns:
A 4-D `Tensor` of shape
`[batch, out_height, out_width, in_channels * channel_multiplier].`
"""
with ops.op_scope([input, filter], name, "depthwise") as name:
input = ops.convert_to_tensor(input, name="tensor_in")
filter = ops.convert_to_tensor(filter, name="filter_in")
# A shape is required to statically compute the number of separable filters.
if filter.get_shape().ndims is not None:
assert len(filter.get_shape()) == 4
in_channels = filter.get_shape()[2]
# Sanity checks, if shape information is available for the inputs.
if input.get_shape().ndims is not None:
assert len(input.get_shape()) == 4
assert input.get_shape()[3] == in_channels, (
"Mismatched input depth %d and number of depthwise filters %d." % (
input.get_shape()[3].value, in_channels))
else:
assert input.get_shape().ndims is not None, (
"Either tensor must provide static shape information.")
assert input.get_shape().ndims == 4
in_channels = input.get_shape()[3]
if in_channels == 1:
return nn_ops.conv2d(input, filter, strides, padding, name=name)
else:
return nn_ops.depthwise_conv2d_native(input, filter, strides, padding,
name=name)
def separable_conv2d(input, depthwise_filter, pointwise_filter, strides,
padding,
name=None):
"""2-D convolution with separable filters.
Performs a depthwise convolution that acts separately on channels followed by
a pointwise convolution that mixes channels. Note that this is separability
between dimensions `[1, 2]` and `3`, not spatial separability between
dimensions `1` and `2`.
In detail,
output[b, i, j, k] = sum_{di, dj, q, r]
input[b, strides[1] * i + di, strides[2] * j + dj, q] *
depthwise_filter[di, dj, q, r] *
pointwise_filter[0, 0, q * channel_multiplier + r, k]
`strides` controls the strides for the depthwise convolution only, since
the pointwise convolution has implicit strides of `[1, 1, 1, 1]`. Must have
`strides[0] = strides[3] = 1`. For the most common case of the same
horizontal and vertical strides, `strides = [1, stride, stride, 1]`.
Args:
input: 4-D `Tensor` with shape `[batch, in_height, in_width, in_channels]`.
depthwise_filter: 4-D `Tensor` with shape
`[filter_height, filter_width, in_channels, channel_multiplier]`.
Contains `in_channels` convolutional filters of depth 1.
pointwise_filter: 4-D `Tensor` with shape
`[1, 1, channel_multiplier * in_channels, out_channels]`. Pointwise
filter to mix channels after `depthwise_filter` has convolved spatially.
strides: 1-D of size 4. The strides for the depthwise convolution for
each dimension of `input`.
padding: A string, either `'VALID'` or `'SAME'`. The padding algorithm.
See the [comment here](https://www.tensorflow.org/api_docs/python/nn.html#convolution)
name: A name for this operation (optional).
Returns:
A 4-D `Tensor` of shape `[batch, out_height, out_width, out_channels]`.
Raises:
ValueError: If channel_multiplier * in_channels > out_channels,
which means that the separable convolution is overparameterized.
"""
with ops.op_scope([input, depthwise_filter, pointwise_filter],
name, "separable_conv2d") as name:
input = ops.convert_to_tensor(input, name="tensor_in")
depthwise_filter = ops.convert_to_tensor(depthwise_filter,
name="depthwise_filter")
pointwise_filter = ops.convert_to_tensor(pointwise_filter,
name="pointwise_filter")
if pointwise_filter.get_shape().ndims is not None:
assert len(pointwise_filter.get_shape()) == 4
assert pointwise_filter.get_shape()[0] == 1
assert pointwise_filter.get_shape()[1] == 1
if depthwise_filter.get_shape().ndims and input.get_shape().ndims:
channel_multiplier = depthwise_filter.get_shape()[3]
in_channels = input.get_shape()[3]
out_channels = pointwise_filter.get_shape()[3]
if channel_multiplier * in_channels > out_channels:
raise ValueError(
("Refusing to perform an overparameterized separable "
"convolution: channel_multiplier * in_channels = "
"%d * %d = %d > %d = out_channels" %
(channel_multiplier, in_channels,
channel_multiplier * in_channels, out_channels)))
# The layout of the ops in the graph are expected to be as follows:
# depthwise_conv2d // Conv2D op corresponding to native deptwise conv.
# separable_conv2d // Conv2D op corresponding to the pointwise conv.
depthwise = nn_ops.depthwise_conv2d_native(input, depthwise_filter, strides,
padding, name="depthwise")
return nn_ops.conv2d(depthwise, pointwise_filter, [1, 1, 1, 1],
padding="VALID", name=name)
def sufficient_statistics(x, axes, shift=None, keep_dims=False, name=None):
"""Calculate the sufficient statistics for the mean and variance of `x`.
These sufficient statistics are computed using the one pass algorithm on
an input that's optionally shifted. See:
https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Computing_shifted_data
Args:
x: A `Tensor`.
axes: Array of ints. Axes along which to compute mean and variance.
shift: A `Tensor` containing the value by which to shift the data for
numerical stability, or `None` if no shift is to be performed. A shift
close to the true mean provides the most numerically stable results.
keep_dims: produce statistics with the same dimensionality as the input.
name: Name used to scope the operations that compute the sufficient stats.
Returns:
Four `Tensor` objects of the same type as `x`:
* the count (number of elements to average over).
* the (possibly shifted) sum of the elements in the array.
* the (possibly shifted) sum of squares of the elements in the array.
* the shift by which the mean must be corrected or None if `shift` is None.
"""
with ops.op_scope([x, axes, shift], name, "sufficient_statistics"):
x = ops.convert_to_tensor(x, name="x")
x_shape = x.get_shape()
if x_shape.is_fully_defined():
counts = 1
m_shape = []
for d in xrange(x_shape.ndims):
dim = x_shape[d].value
if d in set(axes):
counts *= dim
dim = 1
m_shape.append(dim)
counts = constant_op.constant(counts, dtype=x.dtype)
else: # shape needs to be inferred at runtime.
x_shape = array_ops.shape(x)
select_axes = sparse_ops.sparse_to_dense(axes, array_ops.shape(x_shape),
True, False)
m_shape = math_ops.select(select_axes, array_ops.ones_like(x_shape),
x_shape)
counts = math_ops.cast(
math_ops.reduce_prod(x_shape / m_shape),
x.dtype,
name="count")
if shift is not None:
shift = ops.convert_to_tensor(shift, name="shift")
m_ss = math_ops.sub(x, shift)
v_ss = math_ops.squared_difference(x, shift)
else: # no shift.
m_ss = x
v_ss = math_ops.square(x)
m_ss = math_ops.reduce_sum(m_ss, axes, keep_dims=keep_dims, name="mean_ss")
v_ss = math_ops.reduce_sum(v_ss, axes, keep_dims=keep_dims, name="var_ss")
return counts, m_ss, v_ss, shift
def normalize_moments(counts, mean_ss, variance_ss, shift, name=None):
"""Calculate the mean and variance of based on the sufficient statistics.
Args:
counts: A `Tensor` containing a the total count of the data (one value).
mean_ss: A `Tensor` containing the mean sufficient statistics: the (possibly
shifted) sum of the elements to average over.
variance_ss: A `Tensor` containing the variance sufficient statistics: the
(possibly shifted) squared sum of the data to compute the variance over.
shift: A `Tensor` containing the value by which the data is shifted for
numerical stability, or `None` if no shift was performed.
name: Name used to scope the operations that compute the moments.
Returns:
Two `Tensor` objects: `mean` and `variance`.
"""
with ops.op_scope([counts, mean_ss, variance_ss, shift], name, "normalize"):
divisor = math_ops.inv(counts, name="divisor")
if shift is not None:
shifted_mean = math_ops.mul(mean_ss, divisor, name="shifted_mean")
mean = math_ops.add(shifted_mean, shift, name="mean")
else: # no shift.
shifted_mean = math_ops.mul(mean_ss, divisor, name="mean")
mean = shifted_mean
variance = math_ops.sub(
math_ops.mul(variance_ss, divisor),
math_ops.square(shifted_mean),
name="variance")
return (mean, variance)
def moments(x, axes, shift=None, name=None, keep_dims=False):
"""Calculate the mean and variance of `x`.
The mean and variance are calculated by aggregating the contents of `x`
across `axes`. If `x` is 1-D and `axes = [0]` this is just the mean
and variance of a vector.
When using these moments for batch normalization (see
`tf.nn.batch_normalization`):
* for so-called "global normalization", used with convolutional filters with
shape `[batch, height, width, depth]`, pass `axes=[0, 1, 2]`.
* for simple batch normalization pass `axes=[0]` (batch only).
Args:
x: A `Tensor`.
axes: array of ints. Axes along which to compute mean and
variance.
shift: A `Tensor` containing the value by which to shift the data for
numerical stability, or `None` if no shift is to be performed. A shift
close to the true mean provides the most numerically stable results.
keep_dims: produce moments with the same dimensionality as the input.
name: Name used to scope the operations that compute the moments.
Returns:
Two `Tensor` objects: `mean` and `variance`.
"""
with ops.op_scope([x, axes, shift], name, "moments"):
# The dynamic range of fp16 is too limited to support the collection of
# sufficient statistics. As a workaround we simply perform the operations
# on 32-bit floats before converting the mean and variance back to fp16
y = math_ops.cast(x, dtypes.float32) if x.dtype == dtypes.float16 else x
counts, m_ss, v_ss, shift = sufficient_statistics(y,
axes,
shift=shift,
keep_dims=keep_dims,
name=name)
with ops.control_dependencies([counts, m_ss, v_ss]):
mean, variance = normalize_moments(counts, m_ss, v_ss, shift, name=name)
if x.dtype == dtypes.float16:
return (math_ops.cast(mean, dtypes.float16), math_ops.cast(
variance, dtypes.float16))
else:
return (mean, variance)
def batch_normalization(x,
mean,
variance,
offset,
scale,
variance_epsilon,
name=None):
"""Batch normalization.
As described in http://arxiv.org/abs/1502.03167.
Normalizes a tensor by `mean` and `variance`, and applies (optionally) a
`scale` \\\\(\gamma\\\\) to it, as well as an `offset` \\\\(\\beta\\\\):
\\\\(\\frac{\gamma(x-\mu)}{\sigma}+\\beta\\\\)
`mean`, `variance`, `offset` and `scale` are all expected to be of one of two
shapes:
* In all generality, they can have the same number of dimensions as the
input `x`, with identical sizes as `x` for the dimensions that are not
normalized over (the 'depth' dimension(s)), and dimension 1 for the
others which are being normalized over.
`mean` and `variance` in this case would typically be the outputs of
`tf.nn.moments(..., keep_dims=True)` during training, or running averages
thereof during inference.
* In the common case where the 'depth' dimension is the last dimension in
the input tensor `x`, they may be one dimensional tensors of the same
size as the 'depth' dimension.
This is the case for example for the common `[batch, depth]` layout of
fully-connected layers, and `[batch, height, width, depth]` for
convolutions.
`mean` and `variance` in this case would typically be the outputs of
`tf.nn.moments(..., keep_dims=False)` during training, or running averages
thereof during inference.
Args:
x: Input `Tensor` of arbitrary dimensionality.
mean: A mean `Tensor`.
variance: A variance `Tensor`.
offset: An offset `Tensor`, often denoted \\\\(\\beta\\\\) in equations, or
None. If present, will be added to the normalized tensor.
scale: A scale `Tensor`, often denoted \\\\(\gamma\\\\) in equations, or
`None`. If present, the scale is applied to the normalized tensor.
variance_epsilon: A small float number to avoid dividing by 0.
name: A name for this operation (optional).
Returns:
the normalized, scaled, offset tensor.
"""
with ops.op_scope([x, mean, variance, scale, offset], name, "batchnorm"):
inv = math_ops.rsqrt(variance + variance_epsilon)
if scale is not None:
inv *= scale
return x * inv + (
offset - mean * inv if offset is not None else -mean * inv)
def batch_norm_with_global_normalization(t,
m,
v,
beta,
gamma,
variance_epsilon,
scale_after_normalization,
name=None):
"""Batch normalization.
This op is deprecated. See `tf.nn.batch_normalization`.
Args:
t: A 4D input Tensor.
m: A 1D mean Tensor with size matching the last dimension of t.
This is the first output from tf.nn.moments,
or a saved moving average thereof.
v: A 1D variance Tensor with size matching the last dimension of t.
This is the second output from tf.nn.moments,
or a saved moving average thereof.
beta: A 1D beta Tensor with size matching the last dimension of t.
An offset to be added to the normalized tensor.
gamma: A 1D gamma Tensor with size matching the last dimension of t.
If "scale_after_normalization" is true, this tensor will be multiplied
with the normalized tensor.
variance_epsilon: A small float number to avoid dividing by 0.
scale_after_normalization: A bool indicating whether the resulted tensor
needs to be multiplied with gamma.
name: A name for this operation (optional).
Returns:
A batch-normalized `t`.
"""
return batch_normalization(t, m, v, beta, gamma if scale_after_normalization
else None, variance_epsilon, name)
def _sum_rows(x):
"""Returns a vector summing up each row of the matrix x."""
# _sum_rows(x) is equivalent to math_ops.reduce_sum(x, 1) when x is
# a matrix. The gradient of _sum_rows(x) is more efficient than
# reduce_sum(x, 1)'s gradient in today's implementation. Therefore,
# we use _sum_rows(x) in the nce_loss() computation since the loss
# is mostly used for training.
cols = array_ops.shape(x)[1]
ones_shape = array_ops.pack([cols, 1])
ones = array_ops.ones(ones_shape, x.dtype)
return array_ops.reshape(math_ops.matmul(x, ones), [-1])
def _compute_sampled_logits(weights, biases, inputs, labels, num_sampled,
num_classes, num_true=1,
sampled_values=None,
subtract_log_q=True,
remove_accidental_hits=False,
partition_strategy="mod",
name=None):
"""Helper function for nce_loss and sampled_softmax_loss functions.
Computes sampled output training logits and labels suitable for implementing
e.g. noise-contrastive estimation (see nce_loss) or sampled softmax (see
sampled_softmax_loss).
Note: In the case where num_true > 1, we assign to each target class
the target probability 1 / num_true so that the target probabilities
sum to 1 per-example.
Args:
weights: A `Tensor` of shape `[num_classes, dim]`, or a list of `Tensor`
objects whose concatenation along dimension 0 has shape
`[num_classes, dim]`. The (possibly-partitioned) class embeddings.
biases: A `Tensor` of shape `[num_classes]`. The class biases.
inputs: A `Tensor` of shape `[batch_size, dim]`. The forward
activations of the input network.
labels: A `Tensor` of type `int64` and shape `[batch_size,
num_true]`. The target classes. Note that this format differs from
the `labels` argument of `nn.softmax_cross_entropy_with_logits`.
num_sampled: An `int`. The number of classes to randomly sample per batch.
num_classes: An `int`. The number of possible classes.
num_true: An `int`. The number of target classes per training example.
sampled_values: a tuple of (`sampled_candidates`, `true_expected_count`,
`sampled_expected_count`) returned by a `*_candidate_sampler` function.
(if None, we default to `log_uniform_candidate_sampler`)
subtract_log_q: A `bool`. whether to subtract the log expected count of
the labels in the sample to get the logits of the true labels.
Default is True. Turn off for Negative Sampling.
remove_accidental_hits: A `bool`. whether to remove "accidental hits"
where a sampled class equals one of the target classes. Default is
False.
partition_strategy: A string specifying the partitioning strategy, relevant
if `len(weights) > 1`. Currently `"div"` and `"mod"` are supported.
Default is `"mod"`. See `tf.nn.embedding_lookup` for more details.
name: A name for the operation (optional).
Returns:
out_logits, out_labels: `Tensor` objects each with shape
`[batch_size, num_true + num_sampled]`, for passing to either
`nn.sigmoid_cross_entropy_with_logits` (NCE) or
`nn.softmax_cross_entropy_with_logits` (sampled softmax).
"""
if not isinstance(weights, list):
weights = [weights]
with ops.op_scope(
weights + [biases, inputs, labels], name, "compute_sampled_logits"):
if labels.dtype != dtypes.int64:
labels = math_ops.cast(labels, dtypes.int64)
labels_flat = array_ops.reshape(labels, [-1])
# Sample the negative labels.
# sampled shape: [num_sampled] tensor
# true_expected_count shape = [batch_size, 1] tensor
# sampled_expected_count shape = [num_sampled] tensor
if sampled_values is None:
sampled_values = candidate_sampling_ops.log_uniform_candidate_sampler(
true_classes=labels,
num_true=num_true,
num_sampled=num_sampled,
unique=True,
range_max=num_classes)
# NOTE: pylint cannot tell that 'sampled_values' is a sequence
# pylint: disable=unpacking-non-sequence
sampled, true_expected_count, sampled_expected_count = sampled_values
# pylint: enable=unpacking-non-sequence
# labels_flat is a [batch_size * num_true] tensor
# sampled is a [num_sampled] int tensor
all_ids = array_ops.concat(0, [labels_flat, sampled])
# weights shape is [num_classes, dim]
all_w = embedding_ops.embedding_lookup(
weights, all_ids, partition_strategy=partition_strategy)
all_b = embedding_ops.embedding_lookup(biases, all_ids)
# true_w shape is [batch_size * num_true, dim]
# true_b is a [batch_size * num_true] tensor
true_w = array_ops.slice(
all_w, [0, 0], array_ops.pack([array_ops.shape(labels_flat)[0], -1]))
true_b = array_ops.slice(all_b, [0], array_ops.shape(labels_flat))
# inputs shape is [batch_size, dim]
# true_w shape is [batch_size * num_true, dim]
# row_wise_dots is [batch_size, num_true, dim]
dim = array_ops.shape(true_w)[1:2]
new_true_w_shape = array_ops.concat(0, [[-1, num_true], dim])
row_wise_dots = math_ops.mul(
array_ops.expand_dims(inputs, 1),
array_ops.reshape(true_w, new_true_w_shape))
# We want the row-wise dot plus biases which yields a
# [batch_size, num_true] tensor of true_logits.
dots_as_matrix = array_ops.reshape(row_wise_dots,
array_ops.concat(0, [[-1], dim]))
true_logits = array_ops.reshape(_sum_rows(dots_as_matrix), [-1, num_true])
true_b = array_ops.reshape(true_b, [-1, num_true])
true_logits += true_b
# Lookup weights and biases for sampled labels.
# sampled_w shape is [num_sampled, dim]
# sampled_b is a [num_sampled] float tensor
sampled_w = array_ops.slice(
all_w, array_ops.pack([array_ops.shape(labels_flat)[0], 0]), [-1, -1])
sampled_b = array_ops.slice(all_b, array_ops.shape(labels_flat), [-1])
# inputs has shape [batch_size, dim]
# sampled_w has shape [num_sampled, dim]
# sampled_b has shape [num_sampled]
# Apply X*W'+B, which yields [batch_size, num_sampled]
sampled_logits = math_ops.matmul(inputs,
sampled_w,
transpose_b=True) + sampled_b
if remove_accidental_hits:
acc_hits = candidate_sampling_ops.compute_accidental_hits(
labels, sampled, num_true=num_true)
acc_indices, acc_ids, acc_weights = acc_hits
# This is how SparseToDense expects the indices.
acc_indices_2d = array_ops.reshape(acc_indices, [-1, 1])
acc_ids_2d_int32 = array_ops.reshape(math_ops.cast(
acc_ids, dtypes.int32), [-1, 1])
sparse_indices = array_ops.concat(
1, [acc_indices_2d, acc_ids_2d_int32], "sparse_indices")
# Create sampled_logits_shape = [batch_size, num_sampled]
sampled_logits_shape = array_ops.concat(
0,
[array_ops.shape(labels)[:1], array_ops.expand_dims(num_sampled, 0)])
if sampled_logits.dtype != acc_weights.dtype:
acc_weights = math_ops.cast(acc_weights, sampled_logits.dtype)
sampled_logits += sparse_ops.sparse_to_dense(
sparse_indices, sampled_logits_shape, acc_weights,
default_value=0.0, validate_indices=False)
if subtract_log_q:
# Subtract log of Q(l), prior probability that l appears in sampled.
true_logits -= math_ops.log(true_expected_count)
sampled_logits -= math_ops.log(sampled_expected_count)
# Construct output logits and labels. The true labels/logits start at col 0.
out_logits = array_ops.concat(1, [true_logits, sampled_logits])
# true_logits is a float tensor, ones_like(true_logits) is a float tensor
# of ones. We then divide by num_true to ensure the per-example labels sum
# to 1.0, i.e. form a proper probability distribution.
out_labels = array_ops.concat(
1, [array_ops.ones_like(true_logits) / num_true,
array_ops.zeros_like(sampled_logits)])
return out_logits, out_labels
def nce_loss(weights, biases, inputs, labels, num_sampled, num_classes,
num_true=1,
sampled_values=None,
remove_accidental_hits=False,
partition_strategy="mod",
name="nce_loss"):
"""Computes and returns the noise-contrastive estimation training loss.
See [Noise-contrastive estimation: A new estimation principle for
unnormalized statistical models]
(http://www.jmlr.org/proceedings/papers/v9/gutmann10a/gutmann10a.pdf).
Also see our [Candidate Sampling Algorithms Reference]
(../../extras/candidate_sampling.pdf)
Note: In the case where `num_true` > 1, we assign to each target class
the target probability 1 / `num_true` so that the target probabilities
sum to 1 per-example.
Note: It would be useful to allow a variable number of target classes per
example. We hope to provide this functionality in a future release.
For now, if you have a variable number of target classes, you can pad them
out to a constant number by either repeating them or by padding
with an otherwise unused class.
Args:
weights: A `Tensor` of shape `[num_classes, dim]`, or a list of `Tensor`
objects whose concatenation along dimension 0 has shape
[num_classes, dim]. The (possibly-partitioned) class embeddings.
biases: A `Tensor` of shape `[num_classes]`. The class biases.
inputs: A `Tensor` of shape `[batch_size, dim]`. The forward
activations of the input network.
labels: A `Tensor` of type `int64` and shape `[batch_size,
num_true]`. The target classes.
num_sampled: An `int`. The number of classes to randomly sample per batch.
num_classes: An `int`. The number of possible classes.
num_true: An `int`. The number of target classes per training example.
sampled_values: a tuple of (`sampled_candidates`, `true_expected_count`,
`sampled_expected_count`) returned by a `*_candidate_sampler` function.
(if None, we default to `log_uniform_candidate_sampler`)
remove_accidental_hits: A `bool`. Whether to remove "accidental hits"
where a sampled class equals one of the target classes. If set to
`True`, this is a "Sampled Logistic" loss instead of NCE, and we are
learning to generate log-odds instead of log probabilities. See
our [Candidate Sampling Algorithms Reference]
(../../extras/candidate_sampling.pdf).
Default is False.
partition_strategy: A string specifying the partitioning strategy, relevant
if `len(weights) > 1`. Currently `"div"` and `"mod"` are supported.
Default is `"mod"`. See `tf.nn.embedding_lookup` for more details.
name: A name for the operation (optional).
Returns:
A `batch_size` 1-D tensor of per-example NCE losses.
"""
logits, labels = _compute_sampled_logits(
weights, biases, inputs, labels, num_sampled, num_classes,
num_true=num_true,
sampled_values=sampled_values,
subtract_log_q=True,
remove_accidental_hits=remove_accidental_hits,
partition_strategy=partition_strategy,
name=name)
sampled_losses = sigmoid_cross_entropy_with_logits(logits,
labels,
name="sampled_losses")
# sampled_losses is batch_size x {true_loss, sampled_losses...}
# We sum out true and sampled losses.
return _sum_rows(sampled_losses)
def sampled_softmax_loss(weights, biases, inputs, labels, num_sampled,
num_classes, num_true=1,
sampled_values=None,
remove_accidental_hits=True,
partition_strategy="mod",
name="sampled_softmax_loss"):
"""Computes and returns the sampled softmax training loss.
This is a faster way to train a softmax classifier over a huge number of
classes.
This operation is for training only. It is generally an underestimate of
the full softmax loss.
At inference time, you can compute full softmax probabilities with the
expression `tf.nn.softmax(tf.matmul(inputs, tf.transpose(weights)) + biases)`.
See our [Candidate Sampling Algorithms Reference]
(../../extras/candidate_sampling.pdf)
Also see Section 3 of [Jean et al., 2014](http://arxiv.org/abs/1412.2007)
([pdf](http://arxiv.org/pdf/1412.2007.pdf)) for the math.
Args:
weights: A `Tensor` of shape `[num_classes, dim]`, or a list of `Tensor`
objects whose concatenation along dimension 0 has shape
[num_classes, dim]. The (possibly-sharded) class embeddings.
biases: A `Tensor` of shape `[num_classes]`. The class biases.
inputs: A `Tensor` of shape `[batch_size, dim]`. The forward
activations of the input network.
labels: A `Tensor` of type `int64` and shape `[batch_size,
num_true]`. The target classes. Note that this format differs from
the `labels` argument of `nn.softmax_cross_entropy_with_logits`.
num_sampled: An `int`. The number of classes to randomly sample per batch.
num_classes: An `int`. The number of possible classes.
num_true: An `int`. The number of target classes per training example.
sampled_values: a tuple of (`sampled_candidates`, `true_expected_count`,
`sampled_expected_count`) returned by a `*_candidate_sampler` function.
(if None, we default to `log_uniform_candidate_sampler`)
remove_accidental_hits: A `bool`. whether to remove "accidental hits"
where a sampled class equals one of the target classes. Default is
True.
partition_strategy: A string specifying the partitioning strategy, relevant
if `len(weights) > 1`. Currently `"div"` and `"mod"` are supported.
Default is `"mod"`. See `tf.nn.embedding_lookup` for more details.
name: A name for the operation (optional).
Returns:
A `batch_size` 1-D tensor of per-example sampled softmax losses.
"""
logits, labels = _compute_sampled_logits(
weights, biases, inputs, labels, num_sampled, num_classes,
num_true=num_true,
sampled_values=sampled_values,
subtract_log_q=True,
remove_accidental_hits=remove_accidental_hits,
partition_strategy=partition_strategy,
name=name)
sampled_losses = nn_ops.softmax_cross_entropy_with_logits(logits, labels)
# sampled_losses is a [batch_size] tensor.
return sampled_losses
# TODO(cwhipkey): sigmoid and tanh should not be exposed from tf.nn.
__all__ = make_all(__name__)
__all__.append("zero_fraction") # documented in training.py
# Modules whitelisted for reference through tf.nn.
# TODO(cwhipkey): migrate callers to use the submodule directly.
__all__.extend(["nn_ops", "rnn_cell", "seq2seq"])
# Symbols whitelisted for export without documentation.
# TODO(cwhipkey): review these and move to contrib or expose through
# documentation.
__all__.extend([
"all_candidate_sampler",
"batch_norm_with_global_normalization",
"batch_normalization",
"conv2d_backprop_filter",
"conv2d_backprop_input",
"depthwise_conv2d_native",
"lrn",
"relu_layer",
"xw_plus_b",
])
| 42.152514 | 92 | 0.678258 | [
"Apache-2.0"
] | AdityaPai2398/tensorflow | tensorflow/python/ops/nn.py | 51,131 | Python |
"""Benchmarks of Lasso regularization path computation using Lars and CD
The input data is mostly low rank but is a fat infinite tail.
"""
from collections import defaultdict
import gc
import sys
from time import time
import numpy as np
from sklearn.linear_model import lars_path, lars_path_gram
from sklearn.linear_model import lasso_path
from sklearn.datasets import make_regression
def compute_bench(samples_range, features_range):
it = 0
results = defaultdict(lambda: [])
max_it = len(samples_range) * len(features_range)
for n_samples in samples_range:
for n_features in features_range:
it += 1
print('====================')
print('Iteration %03d of %03d' % (it, max_it))
print('====================')
dataset_kwargs = {
'n_samples': n_samples,
'n_features': n_features,
'n_informative': n_features // 10,
'effective_rank': min(n_samples, n_features) / 10,
#'effective_rank': None,
'bias': 0.0,
}
print("n_samples: %d" % n_samples)
print("n_features: %d" % n_features)
X, y = make_regression(**dataset_kwargs)
gc.collect()
print("benchmarking lars_path (with Gram):", end='')
sys.stdout.flush()
tstart = time()
G = np.dot(X.T, X) # precomputed Gram matrix
Xy = np.dot(X.T, y)
lars_path_gram(Xy=Xy, Gram=G, n_samples=y.size, method='lasso')
delta = time() - tstart
print("%0.3fs" % delta)
results['lars_path (with Gram)'].append(delta)
gc.collect()
print("benchmarking lars_path (without Gram):", end='')
sys.stdout.flush()
tstart = time()
lars_path(X, y, method='lasso')
delta = time() - tstart
print("%0.3fs" % delta)
results['lars_path (without Gram)'].append(delta)
gc.collect()
print("benchmarking lasso_path (with Gram):", end='')
sys.stdout.flush()
tstart = time()
lasso_path(X, y, precompute=True)
delta = time() - tstart
print("%0.3fs" % delta)
results['lasso_path (with Gram)'].append(delta)
gc.collect()
print("benchmarking lasso_path (without Gram):", end='')
sys.stdout.flush()
tstart = time()
lasso_path(X, y, precompute=False)
delta = time() - tstart
print("%0.3fs" % delta)
results['lasso_path (without Gram)'].append(delta)
return results
if __name__ == '__main__':
from mpl_toolkits.mplot3d import axes3d # register the 3d projection
import matplotlib.pyplot as plt
samples_range = np.linspace(10, 500, 3).astype(int)
features_range = np.linspace(10, 1400 , 3).astype(int)
results = compute_bench(samples_range, features_range)
max_time = max(max(t) for t in results.values())
fig = plt.figure('scikit-learn Lasso path benchmark results')
i = 1
for c, (label, timings) in zip('bcry', sorted(results.items())):
ax = fig.add_subplot(2, 2, i, projection='3d')
X, Y = np.meshgrid(samples_range, features_range)
Z = np.asarray(timings).reshape(samples_range.shape[0],
features_range.shape[0])
# plot the actual surface
ax.plot_surface(X, Y, Z.T, cstride=1, rstride=1, color=c, alpha=0.8)
# dummy point plot to stick the legend to since surface plot do not
# support legends (yet?)
# ax.plot([1], [1], [1], color=c, label=label)
ax.set_xlabel('n_samples')
ax.set_ylabel('n_features')
ax.set_zlabel('Time (s)')
ax.set_zlim3d(0.0, max_time * 1.1)
ax.set_title(label)
# ax.legend()
i += 1
#plt.show()
| 34.301724 | 76 | 0.563961 | [
"BSD-3-Clause"
] | Giannos-G/scikit-learn_modified | benchmarks/lasso_replicas/bench_plot_lasso_path_83.py | 3,979 | Python |
# -*- encoding: utf-8 -*-
import re
from oops.utils import sudo_support
@sudo_support
def match(command, settings):
return ('command not found' in command.stderr.lower()
and u' ' in command.script)
@sudo_support
def get_new_command(command, settings):
return re.sub(u' ', ' ', command.script)
| 19.875 | 57 | 0.679245 | [
"MIT"
] | lardnicus/oops | oops/rules/fix_alt_space.py | 320 | Python |
from mmcv.cnn import ConvModule
from torch import nn
from torch.utils import checkpoint as cp
from .se_layer import SELayer
class InvertedResidual(nn.Module):
"""InvertedResidual block for MobileNetV2.
Args:
in_channels (int): The input channels of the InvertedResidual block.
out_channels (int): The output channels of the InvertedResidual block.
stride (int): Stride of the middle (first) 3x3 convolution.
expand_ratio (int): Adjusts number of channels of the hidden layer
in InvertedResidual by this amount.
dilation (int): Dilation rate of depthwise conv. Default: 1
conv_cfg (dict): Config dict for convolution layer.
Default: None, which means using conv2d.
norm_cfg (dict): Config dict for normalization layer.
Default: dict(type='BN').
act_cfg (dict): Config dict for activation layer.
Default: dict(type='ReLU6').
with_cp (bool): Use checkpoint or not. Using checkpoint will save some
memory while slowing down the training speed. Default: False.
Returns:
Tensor: The output tensor.
"""
def __init__(self,
in_channels,
out_channels,
stride,
expand_ratio,
dilation=1,
conv_cfg=None,
norm_cfg=dict(type='BN'),
act_cfg=dict(type='ReLU6'),
with_cp=False):
super(InvertedResidual, self).__init__()
self.stride = stride
assert stride in [1, 2], f'stride must in [1, 2]. ' \
f'But received {stride}.'
self.with_cp = with_cp
self.use_res_connect = self.stride == 1 and in_channels == out_channels
hidden_dim = int(round(in_channels * expand_ratio))
layers = []
if expand_ratio != 1:
layers.append(
ConvModule(
in_channels=in_channels,
out_channels=hidden_dim,
kernel_size=1,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
act_cfg=act_cfg))
layers.extend([
ConvModule(
in_channels=hidden_dim,
out_channels=hidden_dim,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
groups=hidden_dim,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
act_cfg=act_cfg),
ConvModule(
in_channels=hidden_dim,
out_channels=out_channels,
kernel_size=1,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
act_cfg=None)
])
self.conv = nn.Sequential(*layers)
def forward(self, x):
def _inner_forward(x):
if self.use_res_connect:
return x + self.conv(x)
else:
return self.conv(x)
if self.with_cp and x.requires_grad:
out = cp.checkpoint(_inner_forward, x)
else:
out = _inner_forward(x)
return out
class InvertedResidualV3(nn.Module):
"""Inverted Residual Block for MobileNetV3.
Args:
in_channels (int): The input channels of this Module.
out_channels (int): The output channels of this Module.
mid_channels (int): The input channels of the depthwise convolution.
kernel_size (int): The kernel size of the depthwise convolution.
Default: 3.
stride (int): The stride of the depthwise convolution. Default: 1.
se_cfg (dict): Config dict for se layer. Default: None, which means no
se layer.
with_expand_conv (bool): Use expand conv or not. If set False,
mid_channels must be the same with in_channels. Default: True.
conv_cfg (dict): Config dict for convolution layer. Default: None,
which means using conv2d.
norm_cfg (dict): Config dict for normalization layer.
Default: dict(type='BN').
act_cfg (dict): Config dict for activation layer.
Default: dict(type='ReLU').
with_cp (bool): Use checkpoint or not. Using checkpoint will save some
memory while slowing down the training speed. Default: False.
Returns:
Tensor: The output tensor.
"""
def __init__(self,
in_channels,
out_channels,
mid_channels,
kernel_size=3,
stride=1,
se_cfg=None,
with_expand_conv=True,
conv_cfg=None,
norm_cfg=dict(type='BN'),
act_cfg=dict(type='ReLU'),
with_cp=False):
super(InvertedResidualV3, self).__init__()
self.with_res_shortcut = (stride == 1 and in_channels == out_channels)
assert stride in [1, 2]
self.with_cp = with_cp
self.with_se = se_cfg is not None
self.with_expand_conv = with_expand_conv
if self.with_se:
assert isinstance(se_cfg, dict)
if not self.with_expand_conv:
assert mid_channels == in_channels
if self.with_expand_conv:
self.expand_conv = ConvModule(
in_channels=in_channels,
out_channels=mid_channels,
kernel_size=1,
stride=1,
padding=0,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
act_cfg=act_cfg)
self.depthwise_conv = ConvModule(
in_channels=mid_channels,
out_channels=mid_channels,
kernel_size=kernel_size,
stride=stride,
padding=kernel_size // 2,
groups=mid_channels,
conv_cfg=dict(
type='Conv2dAdaptivePadding') if stride == 2 else conv_cfg,
norm_cfg=norm_cfg,
act_cfg=act_cfg)
if self.with_se:
self.se = SELayer(**se_cfg)
self.linear_conv = ConvModule(
in_channels=mid_channels,
out_channels=out_channels,
kernel_size=1,
stride=1,
padding=0,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
act_cfg=None)
def forward(self, x):
def _inner_forward(x):
out = x
if self.with_expand_conv:
out = self.expand_conv(out)
out = self.depthwise_conv(out)
if self.with_se:
out = self.se(out)
out = self.linear_conv(out)
if self.with_res_shortcut:
return x + out
else:
return out
if self.with_cp and x.requires_grad:
out = cp.checkpoint(_inner_forward, x)
else:
out = _inner_forward(x)
return out
| 34.511962 | 80 | 0.537224 | [
"Apache-2.0"
] | vietawake/mmSegmentation | mmseg/models/utils/inverted_residual.py | 7,213 | Python |
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import pandas as pd
import json
import glob
import os
import argparse
from typing import Tuple, Union, List
from collections import Counter
from tqdm import tqdm
from multiprocessing import Pool
pd.options.mode.chained_assignment = None # default='warn'
# ====================================================================
def get_data(img_pth: Union[str, os.PathLike]) -> dict:
"""Get a single data from the given file.json path"""
with open(img_pth, 'r') as f:
data = json.load(f)
return data
def get_original_df(
path: Union[str, os.PathLike],
filename: str,
processes_per_cpu: int = 2) -> Tuple[pd.DataFrame, bool]:
"""Get a DataFrame from all the can_bus*.json files in the dataset"""
save_path = os.path.join(os.getcwd(), 'data_analysis', filename)
if os.path.isfile(save_path):
print('.npy file exists, loading it...')
data = list(np.load(save_path, allow_pickle=True))
else:
# Construct the dataset
print('.npy file not found, constructing it...')
all_data_paths = sorted(glob.glob(os.path.join(path, '**/can_bus*.json'), recursive=True))
with Pool(os.cpu_count() * processes_per_cpu) as p:
data = list(tqdm(p.imap(get_data, all_data_paths), total=len(all_data_paths)))
np.save(save_path, data)
# Create dataframe with the data
df = pd.DataFrame(data)
print(df.describe())
return df, False
# ====================================================================
def get_augmented_df(preloads_name: str) -> Tuple[pd.DataFrame, bool]:
"""Use the preloads file to load the data; will be augmented, as that's what we did"""
assert preloads_name.endswith('.npy')
data = np.load(os.path.join(os.getcwd(), '_preloads', preloads_name), allow_pickle=True)[1]
df = pd.DataFrame(data)
print(df.describe())
return df, True
# ====================================================================
def violin_plot(df: pd.DataFrame, save_name: str, augmented: bool) -> None:
"""Save violin plot for the interesting parameters using df"""
directions_dict = {'No Action': 2.0, 'Turn Left': 3.0, 'Turn Right': 4.0, 'Continue Straight': 5.0}
# Auxiliary function for setting the quartile lines
def set_lines(ax):
for l in ax.lines:
l.set_linestyle('--')
l.set_linewidth(0.6)
l.set_color('white')
l.set_alpha(0.7)
for l in ax.lines[1::3]:
l.set_linestyle('-')
l.set_linewidth(1.3)
l.set_color('black')
l.set_alpha(0.8)
for key in directions_dict:
# Get respective subset of the dataframe
data = df[df['directions'] == directions_dict[key]]
fig = plt.figure(figsize=(8, 6))
gs = fig.add_gridspec(1, 4)
fig.add_subplot(gs[0, 0])
ax = sns.violinplot(y='steer', data=data, color='r', inner='quartile')
set_lines(ax)
fig.add_subplot(gs[0, 1])
ax = sns.violinplot(y='throttle', data=data, color='g', inner='quartile')
set_lines(ax)
fig.add_subplot(gs[0, 2])
ax = sns.violinplot(y='brake', data=data, color='b', inner='quartile')
set_lines(ax)
fig.add_subplot(gs[0, 3])
ax = sns.violinplot(y='speed', data=data, color='m', inner='quartile')
set_lines(ax)
# When using tight layout, we need the title to be spaced accordingly
fig.tight_layout()
fig.subplots_adjust(top=0.88)
stitle = f'Direction: {key} - $N={len(data)}$ - ${100 * len(data)/len(df):6.3f}$% of total'
stitle = f'{stitle} - Augmented' if augmented else stitle
fig.suptitle(stitle, fontsize=16)
fname = f'{save_name}-{key.replace(" ", "")}'
fname = f'{fname}-aug' if augmented else fname
fig_name = os.path.join(os.getcwd(), 'data_analysis', save_name, 'violin_plots', f'{fname}.png')
os.makedirs(os.path.join(os.getcwd(), 'data_analysis', save_name, 'violin_plots'), exist_ok=True)
plt.savefig(fig_name)
plt.close()
# ====================================================================
def plot_clients(path: Union[str, os.PathLike], df: pd.DataFrame, augmented: bool, speed_factor: float) -> None:
"""Plot the steer, throttle, brake, and speed of a client during its data collection"""
# Some sanity check
if path.endswith(os.sep):
path = path[:-1]
# Get dataset name and make the necessary directories
dataset_name = os.path.basename(path)
s_path = os.path.join(os.getcwd(), 'data_analysis', dataset_name, 'clients')
os.makedirs(s_path, exist_ok=True)
# Get the number of clients/cars that collected the data
clients = glob.glob(os.path.join(path, '**/*'))
clients = [cl for cl in clients if os.path.isdir(cl)] # Remove path of metadata.json
num_clients = len(clients)
# Total number of frames and for a single client
num_frames = len(df)
num_frames_per_client = num_frames // num_clients
# Aux function
def get_change_locs(df: pd.DataFrame, cli: int) -> Tuple[List[int], List[float]]:
"""Get the index and directions from the df of the actions taken by the client"""
df['directions_str'] = df['directions'].astype(str) # In order to compare, turn directions into a string
# Shift directions column by 1 (filling the top with the head), and compare to the original
df['change'] = df['directions_str'].shift(1, fill_value=df['directions_str'].head(1)) != df['directions_str']
# Get the rows where there's a change
index_change = list(df.loc[df['change'] == True].index.values)
# Add the first frame
index_change = [(cli - 1) * len(df)] + index_change
# For these indexes, get the value of the direction
dirs = list(df['directions'][index_change].values)
# Add the last frame
index_change = index_change + [cli * len(df) - 1]
return index_change, dirs
# Dictionaries containing the name and color for plotting the direction given to the car
my_labels = {2.0: 'No Action', 3.0: 'Turn Left', 4.0: 'Turn Right', 5.0: 'Continue Straight'}
colors = {2.0: 'gold', 3.0: 'gray', 4.0: 'cyan', 5.0: 'magenta'}
# Initialize the total counts per action
total_action_counts = Counter({2.0: 0, 3.0: 0, 4.0: 0, 5.0: 0})
max_speed_clients = {}
idx_change_clients = {}
dirs_clients = {}
# Make a plot for each client
for client in tqdm(range(1, num_clients + 1), total=num_clients, unit='clients'):
if augmented:
# Dataframe will have augmented data, which uses center, left, right, center, ... data
df_client = df[(client - 1) * num_frames_per_client: client * num_frames_per_client: 3]
else:
df_client = df[(client - 1) * num_frames_per_client: client * num_frames_per_client]
# Augmented data will have been normalized already
df_client['speed'] = df_client['speed'].div(speed_factor) # normalize to range [0, 1]
# The actual max speed (see if it differs from collected data)
actual_max_speed = df_client['speed'].max()
max_speed_clients[client] = actual_max_speed
# Build the plot
fig, ax = plt.subplots(figsize=(48, 16))
fig.tight_layout(rect=[0, 0.03, 1, 0.95])
df_client.plot(y=['steer', 'throttle', 'brake', 'speed'], ax=ax)
# Set the area colors for when an direction is taken
idx_change, dirs = get_change_locs(df_client, client)
for idx, dir in enumerate(dirs):
ax.axvspan(idx_change[idx], idx_change[idx + 1], facecolor=colors[dir], alpha=0.5, label=my_labels[dir])
# Save these index and directions for each client
idx_change_clients[f'client_{client:02d}'] = [int(idx) for idx in idx_change]
dirs_clients[f'client_{client:02d}'] = [float(d) for d in dirs]
# Count the directions taken by the client
dirs_count = Counter(dirs)
# Add this to the total for the whole dataset
total_action_counts += dirs_count
# Add the counts to the title
total_actions = ''
for key in my_labels:
total_actions += f' - {my_labels[key]}: {dirs_count[key]}'
# Set title and x and y axes labels
suptitle = f'Client {client} - Actual max speed: {actual_max_speed:.4f}'
suptitle = f'{suptitle} - Augmented' if augmented else suptitle
suptitle = f'{suptitle}{total_actions}'
plt.suptitle(suptitle, fontsize=30)
plt.xlabel('Frame idx', fontsize=22)
plt.ylabel('Normed value', fontsize=22)
plt.xticks(list(range((client - 1) * num_frames_per_client,
client * num_frames_per_client + 1, len(df_client) // 20))) # ticks in 5% increments
# Fix the legend / remove duplicated areas and labels
hand, labl = ax.get_legend_handles_labels()
handout = []
lablout = []
for h, l in zip(hand, labl):
if l not in lablout:
lablout.append(l)
handout.append(h)
ax.legend(handout, lablout, fontsize='x-large')
sname = os.path.join(s_path, f'{dataset_name}_Client{client:02d}')
sname = f'{sname}-aug' if augmented else sname
plt.savefig(f'{sname}.png', dpi=300)
plt.close()
# Add summary and save it as a JSON file
actions_summary = {
'avg_no_action': total_action_counts[2.0] / num_clients,
'avg_turn_left': total_action_counts[3.0] / num_clients,
'avg_turn_right': total_action_counts[4.0] / num_clients,
'avg_continue_straight': total_action_counts[5.0] / num_clients
}
summary = {
'num_clients': num_clients,
'num_frames_per_client': num_frames_per_client,
'hours_per_client': num_frames_per_client / (20 * 60 * 60),
'total_action_counts': total_action_counts,
'actions_summary': actions_summary,
'max_speed_clients': max_speed_clients,
'idx_change_clients': idx_change_clients,
'dirs_clients': dirs_clients
}
with open(os.path.join(s_path, f'{dataset_name}-summary.json'), 'w') as f:
json.dump(summary, f, indent=4)
# ====================================================================
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--path', type=str, help='Path to the head of the dataset', required=True)
parser.add_argument('--filename', type=str, help='Name of file to save', default=None)
parser.add_argument('--preloads-name', type=str, help='Name of preload file', default=None)
parser.add_argument('--processes-per-cpu', '-proc', type=int, help='Processes per cpu (default: %(default)s)', default=2)
parser.add_argument('--speed-factor', '-sf', type=float, help='Speed factor to normalize data (default: %(default)s)', default=14.0)
parser.add_argument('--plot-clients', action='store_true', help='Add flag to plot the actions and speed of a client')
args = parser.parse_args()
# Create dir if it doesn't exist
if not os.path.exists(os.path.join(os.getcwd(), 'data_analysis')):
os.mkdir(os.path.join(os.getcwd(), 'data_analysis'))
print('Getting the dataframe...')
if args.preloads_name is not None:
# Preloaded data is augmented
df, augmented = get_augmented_df(preloads_name=args.preloads_name)
save_name = os.path.basename(args.preloads_name).split('.')[0]
else:
assert args.filename is not None
assert args.filename.endswith('.npy')
df, augmented = get_original_df(args.path, args.filename, args.processes_per_cpu)
save_name = os.path.basename(args.filename).split('.')[0]
# Create and save the violin plots
print('Plotting data...')
violin_plot(df, save_name, augmented)
if args.plot_clients:
print(f'Plotting actions taken by all clients in {args.path}...')
plot_clients(path=args.path, df=df, augmented=augmented, speed_factor=args.speed_factor)
print('Done!')
# ====================================================================
if __name__ == '__main__':
main()
# ====================================================================
| 39.833333 | 136 | 0.61466 | [
"MIT"
] | PDillis/coiltraine | analyze_dataset.py | 12,428 | Python |
#! /usr/bin/env python
#coding=utf-8
import ply.lex as lex
# LEX for parsing Python
# Tokens
tokens=('VARIABLE','NUMBER', 'IF', 'ELIF', 'ELSE', 'WHILE', 'FOR', 'PRINT', 'INC', 'LEN', 'GDIV', 'BREAK', 'LET')
literals=['=','+','-','*','(',')','{','}','<','>', ';', ',', '[', ']']
#Define of tokens
def t_NUMBER(t):
r'[0-9]+'
return t
def t_PRINT(t):
r'print'
return t
def t_IF(t):
r'if'
return t
def t_WHILE(t):
r'while'
return t
def t_FOR(t):
r'for'
return t
def t_LEN(t):
r'len'
return t
def t_INC(t):
'\+\+'
return t
def t_GDIV(t):
r'//'
return t
def t_BREAK(t):
r'break'
return t
def t_LET(t):
r'<='
return t
def t_ELIF(t):
r'elif'
return t
def t_ELSE(t):
r'else'
return t
def t_VARIABLE(t):
r'[a-zA-Z_]+'
return t
# Ignored
t_ignore = " \t"
def t_error(t):
print("Illegal character '%s'" % t.value[0])
t.lexer.skip(1)
lex.lex()
| 14.013514 | 114 | 0.479267 | [
"MIT"
] | Spico197/PythonCompilerPrinciplesExp | py_lex.py | 1,037 | Python |
from maneuvers.kit import *
from maneuvers.strikes.aerial_strike import AerialStrike
class AerialShot(AerialStrike):
def intercept_predicate(self, car: Car, ball: Ball):
return ball.position[2] > 500
def configure(self, intercept: AerialIntercept):
ball = intercept.ball
target_direction = ground_direction(ball, self.target)
hit_dir = direction(ball.velocity, target_direction * 4000)
self.arrive.target = intercept.ground_pos - ground(hit_dir) * 130
self.aerial.target = intercept.ball.position - ground(hit_dir) * 130
self.arrive.time = intercept.time
self.aerial.arrival_time = intercept.time | 35.1 | 77 | 0.682336 | [
"MIT"
] | RLMarvin/RLBotPack | RLBotPack/BotimusPrime/maneuvers/strikes/aerial_shot.py | 702 | Python |
#from collections import Counter
import requests
from bs4 import BeautifulSoup
from tabulate import tabulate
import backoff
import json
@backoff.on_exception(backoff.expo,
requests.exceptions.RequestException,
max_time=60)
def get_url(url):#, headers):
return requests.get(url) #, headers=headers)
URL = 'http://www.cancerimagingarchive.net/collections/'
page = get_url(URL)
soup = BeautifulSoup(page.content, "html.parser")
table = soup.find(id="tablepress-9")
#print(table.prettify())
rows = table.find_all("tr")
analysis_details = []
with open("output/image_analyses_details.json") as analysis_details_file:
analysis_details = json.load(analysis_details_file)
print("analysis details:")
print(analysis_details)
table = []
header = "Collection,DOI,CancerType,Location,Species,Subjects,ImageTypes,SupportingData,Access,Status,Updated".split(",")
for row in rows:
trow = {}
cols = row.find_all("td")
for cid, col in enumerate(cols):
if cid == 0:
trow[header[0]] = col.find("a").text
trow[header[1]] = col.find("a")["href"]
if not trow[header[1]].startswith("http"):
trow[header[1]] = "http:"+col.find("a")["href"]
else:
trow[header[cid+1]] = col.text
if len(trow):
table = table + [trow]
if trow["SupportingData"].find("Image Analyses")>=0:
if trow["Collection"] not in [ i["Collection"] for i in analysis_details]:
analysis_details.append({"Collection": trow["Collection"], "DOI":trow["DOI"], "Format":"", "CollectionType": "original", "DICOMstatus": "", "DICOMtarget": "", "Comment": ""})
print(len(rows))
with open("output/collections.json", "w") as f:
f.write(json.dumps(table, indent=2))
with open("output/image_analyses_details.json", "w") as f:
f.write(json.dumps(analysis_details, indent=2))
| 27.117647 | 182 | 0.676247 | [
"MIT"
] | fedorov/actcianable | scrapers/get_collections.py | 1,844 | Python |
from django.template.defaulttags import register
@register.filter
def get(data, key):
return data.get(key, '')
| 16.714286 | 48 | 0.735043 | [
"Apache-2.0"
] | TransparentHealth/smh-organization | apps/common/templatetags/smhtags.py | 117 | Python |
"""This script runs code quality checks on given Python files.
Note: This script assumes you use Poetry as your dependency manager.
Run the following in your terminal to get help on how to use this script:
```shell
poetry run python check_commit.py -h
```
"""
import argparse
import subprocess
from colorama import Fore, Style, deinit, init
def blue_bold(message: str) -> str:
return f'{Fore.BLUE}{Style.BRIGHT}{message}{Style.RESET_ALL}'
def light(message: str) -> str:
return f'{Style.DIM}{message}{Style.RESET_ALL}'
def run_task(task_message: str, command: str) -> None:
"""Run a task in the shell, defined by a task message and its associated
command."""
print(blue_bold(task_message))
print(light(f'$ {command}'))
subprocess.call(command, shell=True)
print()
if __name__ == '__main__':
# initialise terminal colors
init()
# create parser
parser = argparse.ArgumentParser(
description=(
f'Run code quality checks on the given Python files. By default '
f'this script runs isort, Black and Flake8 successively but you '
f'can use the parameters to selectively run some of these checks.'
),
epilog=(
'examples:\n'
'\n'
' # run all checks on the my_package/ Python package\n'
' $ poetry run python check_commit.py my_package\n'
'\n'
' # run Black and Flake8 on the la.py file and the foo/ folder\n'
' $ poetry run python check_commit.py -b -f8 la.py foo\n'
),
formatter_class=argparse.RawTextHelpFormatter,
)
# add parser arguments
parser.add_argument(
'-i',
'--isort',
help='run isort on the given files',
action='store_true',
)
parser.add_argument(
'-b',
'--black',
help='run Black on the given files',
action='store_true',
)
parser.add_argument(
'-f8',
'--flake8',
help='run Flake8 on the given files',
action='store_true',
)
parser.add_argument(
'files', type=str, nargs='+', help='list of files or directories',
)
# parse arguments
args = parser.parse_args()
# run checks
run_all_checks = not args.isort and not args.black and not args.flake8
files = ' '.join(args.files)
if run_all_checks or args.isort:
run_task(
'Run import autosorting with isort...',
f'poetry run isort -rc {files}',
)
if run_all_checks or args.black:
run_task(
'Run code formatting with Black...', f'poetry run black {files}',
)
if run_all_checks or args.flake8:
run_task(
'Run code linting with Flake8...', f'poetry run flake8 {files}',
)
# de-initialise terminal colors
deinit()
| 27.09434 | 78 | 0.605153 | [
"Apache-2.0"
] | Cocopyth/foodshare | check_commit.py | 2,872 | Python |
#!/usr/bin/env python3
# coding=utf8
from soco import SoCo
import socket
# http://docs.python-soco.com/en/latest/getting_started.html
class SpeakerSonos:
def __init__(self):
print("SpeakerSonos initialized!")
def do(self, params):
speaker = SoCo(socket.gethostbyname(params['host']))
print(speaker.groups)
if 'volume' in params:
speaker.volume = params['volume']
if 'clear_queue' in params:
speaker.clear_queue()
if 'add_playlist_id_to_queue' in params:
playlist = speaker.get_sonos_playlists()[params['add_playlist_id_to_queue']]
speaker.add_uri_to_queue(playlist.resources[0].uri)
if 'switch_to_tv' in params:
speaker.switch_to_tv()
if 'next' in params:
speaker.next()
elif 'previous' in params:
speaker.previous()
if 'play' in params:
speaker.play()
elif 'pause' in params:
speaker.pause()
if 'set_sleep_timer' in params:
speaker.set_sleep_timer(params['set_sleep_timer'] * 60)
| 27.195122 | 88 | 0.613453 | [
"MIT"
] | mrusme/melon | plugins/speaker_sonos.py | 1,115 | Python |
import os
'''
TableData deals with data that comes from MS Excel, csv, xml. More precisely, it expects
a single table which has headings in the first row. It converts between these formats and usually keeps
information on a round trip between those formats identical.
TableData also allows for simple transformations, like dropping a column.
CONVENTIONS
*cid is column no or column id
*rid is row no or row id
*cell refers the content of a cell, a cell is represented by cid|rid, as two integers or (not sure yet) a tuple or a list
*cname is the column name (in row 0)
NOTE
* (x|y) not rows x cols
* Currently internal cells do have a type, which may be flattened to str if output is type agnostic.
* cid and rid begins with 0, so first cell is 0|0, but ncols and nrows start at 1. Strangely enough, sometimes that is convenient.
* interface prefers cname over cid
LIMITATIONS
Data is stored in memory (in a two dimensional list of lists), so max. size depends on available memory (ram).
WHAT NOT TO DO
I will NOT allow conversion INTO Excel xsl format, only reading from it.
I will not abstract this thing too far. I write it for my current Excel version and the csv flavor that I
need (e.g. csv is escaped only for values that contain commas). I don't need multiple Excel sheets,
formatting in Excel, lots of types in Excel.
UNICODE
I am going for UTF-8 encoding, but not sure I have it everywhere yet. xlrd is internally in UTF16LE, I believe.
Roundtrip Exceptions
*date
XML Format made by TableData is
<tdx>
<row>
<cnameA>cell value</cnameA>
<cnameB>cell value</cnameB>
...
</row>
</tdx>
The first row will have all columns, even empty ones. The other rows usually omit empty elements with empty values.
'''
class TableData:
def verbose (self, msg):
if self._verbose:
print (msg)
def _uniqueColumns (self):
'''
raise exception if column names (cnames) are not unique
'''
if len(set(self.table[0])) != len(self.table[0]):
raise Exception('Column names not unique')
def __init__ (self, ingester, infile, verbose=None):
self._verbose=verbose
if ingester == 'xml':
self.XMLParser(infile)
elif ingester == 'xls':
self.XLRDParser(infile)
elif ingester == 'csv':
self.CSVParser(infile)
elif ingester == 'json':
self.JSONParser(infile)
#todo: modern excel
else:
raise Exception ('Ingester %s not found' % ingester)
self._uniqueColumns()
#
# INGESTERS (xml, csv)
#
def load_table (path, verbose=None):
'''
File extension aware ingester
td=TableData.load_table(path)
This is an alternative to _init_. Is this pythonic enough?
'''
ext=os.path.splitext(path)[1][1:]
return TableData (ext, path,verbose)
def XLRDParser (self, infile):
'''
Parses old excel file into tableData object. Only first sheet.
Dont use this directly, use
td=TableData('xsl', infile)
td=TableData.load=table(infile)
instead
xlrd uses UTF16. What comes out of here?
TO DO:
1. better tests for
-Unicode issues not tested
-Excel data fields change appearance
2. conversion/transformation stuff
'''
import xlrd
import xlrd.sheet
from xlrd.sheet import ctype_text
self.table=[] # will hold sheet in memory as list of list
self.verbose ('xlrd infile %s' % infile)
#if not os.path.isfile(infile):
# raise Exception ('Input file not found')
wb = xlrd.open_workbook(filename=infile, on_demand=True)
sheet= wb.sheet_by_index(0)
#I'm assuming here that first row consist only of text cells?
#start at r=0 because we want to preserve the columns
for r in range(0, sheet.nrows): #no
row=[]
for c in range(sheet.ncols):
cell = sheet.cell(r, c)
cellTypeStr = ctype_text.get(cell.ctype, 'unknown type')
val=cell.value
#convert cell types -> dates look changed, but may not be (seconds since epoch)!
if cellTypeStr == "number":
val=int(float(val))
elif cellTypeStr == "xldate":
val=xlrd.xldate.xldate_as_datetime(val, 0)
#Warn if comma -> to check if escaped correctly -> quoting works
#if ',' in str(val):
# self.verbose ("%i/%i contains a comma" % (c,r) )
row.append(val)
self.table.append(row)
wb.unload_sheet(0) #unload xlrd sheet to save memory
def CSVParser (self,infile):
import csv
self.table=[] # will hold sheet in memory as list of list
self.verbose ('csvParser: ' + str(infile))
with open(infile, mode='r', newline='') as csvfile:
incsv = csv.reader(csvfile, dialect='excel')
for row in incsv:
self.table.append(row)
#self.verbose (str(row))
def XMLParser (self,infile):
#It is practically impossible to reconstruct the full list of columns from xml file
#if xmlWriter leaves out empty elements. Instead, I write them at least for first row.
self.table=[] # will hold sheet in memory as list of list; overwrite
self.verbose ('xml infile %s' % infile)
import xml.etree.ElementTree as ET
tree = ET.parse(infile)
for row in tree.iter("row"):
c=0
cnames=[]
col=[]
for e in row.iter():
if e.tag !='row':
#self.verbose ('%s %s' % (e.tag, e.text))
if len(self.table) == 0:
#need to create 2 rows from first row in xml
cnames.append(e.tag)
col.append(e.text)
if len(self.table) == 0:
self.table.append(cnames)
self.table.append(col)
#self.verbose (self.table)
def JSONParser (self, infile):
self.table=[] # will hold sheet in memory as list of list; overwrite
import json
self.verbose ('json infile %s' % infile)
json_data = open(infile, 'r').read()
self.table = json.loads(json_data)
##
## read table data, but NO manipulations
##
def ncols(self):
'''
Returns integer with number of columns in table data
'''
return len(self.table[0])
def nrows (self):
'''
Returns integer with number of rows in table data
'''
return len(self.table)
def cell (self, col,row):
'''
Return a cell for col,row.
td.cell(col,row)
Throws exception if col or row are not integer or out of range.
What happens on empty cell?
I stick to x|y format, although row|col might be more pythonic.
Empty cell is '' not None.
'''
try:
return self.table[row][col]
except:
self.verbose ('%i|%i doesnt exist' % (col, row))
exit (1)
def cindex (self,needle):
'''
Returns the column index (c) for column name 'needle'.
Throws 'not in list' if 'needle' is not a column name (cname).
'''
return self.table[0].index(needle)
def colExists (self, cname):
try:
self.table[0].index(cname)
return True
except:
return False
def search (self, needle):
'''
Returns list of cells [cid,rid] that contain the needle.
r=td.search(needle) # (1,1)
tuples, lists? I am not quite sure!
'''
results=[]
for rid in range(0, self.nrows()):
for cid in range(0, self.ncols()):
cell=self.cell(cid, rid)
#self.verbose ('ce:'+str(cell))
if str(needle) in str(cell):
#self.verbose ("%i/%i:%s->%s" % (cid, rid, cell, needle))
results.append ((cid,rid))
return results
def search_col (self, cname, needle):
'''
Returns list/set of rows that contain the needle for the given col.
td.search(cname, needle)
'''
results=()
c=cindex(cname)
for rid in range(0, self.nrows()):
if needle in self.cell(c,rid):
results.append(rid)
def show (self):
'''
print representation of table
Really print? Why not.
'''
for row in self.table:
print (row)
print ('Table size is %i x %i (cols x rows)' % (self.ncols(), self.nrows()))
##
## SIMPLE UNCONDITIONAL TRANSFORMATIONS
##
def delRow (self, r):
'''
Drop a row by number.
Need to remake the index to cover the hole.
'''
#r always means rid
self.table.pop(r)
#print ('row %i deleted' % r)
def delCol (self, cname):
'''
Drop a column by cname
(Not tested.)
'''
c=self.cindex (cname)
for r in range(0, self.nrows()):
self.table[r].pop(c)
def addCol (self,name):
'''
Add a new column called name at the end of the row.
Cells with be empty.
Returns the cid of the new column, same as cindex(cname).
'''
#update
self.table[0].append(name)
self._uniqueColumns()
for rid in range(1, self.nrows()):
self.table[rid].append('') # append empty cells for all rows
return len(self.table[0])-1 # len starts counting at 1, but I want 0
def clean_whitespace (self,cname):
cid=self.cindex(cname)
for rid in range(1, td.nrows()):
td.table[rid][cid]=td.table[rid][cid].replace('\r\n', ' ').replace(' ', ' ')
##
## MORE COMPLEX MANIPULATION
##
def delCellAIfColBEq (self,cnameA, cnameB, needle):
'''
empty cell in column cnameA if value in column cnameB equals needle in every row
untested
'''
colA=self.cindex(cnameA)
colB=self.cindex(cnameB)
for rid in range(1, self.nrows()):
if self.table[rid][colB] == needle:
self.verbose ('delCellAifColBEq A:%s, B:%s, needle %s' % (cnameA, cnameB, needle))
selt.table[rid][colA]=''
def delCellAIfColBContains (self,col_a, col_b, needle): pass
def delRowIfColContains (self, cname, needle):
'''
Delete row if column equals the value 'needle'
Should we use cname or c (colId)?
'''
#cant loop thru rows and delete one during the loop
col=self.cindex(cname)
#it appears that excel and xlrd start with 1
#todo: not sure why I have shave off one here!
r=self.nrows()-1
while r> 1:
#print ('AA%i/%i: ' % (r,col))
cell=self.cell (r, col)
if needle in str(cell):
#print ('DD:%i/%s:%s' % (r, cname, cell))
#print ('delRowIfColEq: needle %s found in row %i'% (needle, r))
self.delRow(r)
r -=1
def delRowIfColEq (self,col, needle): pass
def renameCol (self, cnameOld, cnameNew):
'''
renames column cnameOld into cnameNew
'''
c=self.cindex(cnameOld)
self.table[0][c]=cnameNew
def default_per_col (cname, default_value):
'''
Default Value: if cell is empty replace with default value
self.default_per_col ('status', 'filled')
'''
cid=td.cindex(cname)
for rid in range(1, td.nrows()):
if not td.cell (cid,rid):
self.table[rid][cid]=default_value
###
### converting to outside world
###
def _outTest(self,out):
if os.path.exists(out):
self.verbose('Output exists already, will be overwritten: %s' %out)
def write (self, out):
'''
write to file with extension-awareness
'''
ext=os.path.splitext(out)[1][1:].lower()
if (ext == 'xml'):
self.writeXML (out)
elif (ext == 'csv'):
self.writeCSV (out)
elif (ext == 'json'):
self.writeJSON (out)
else:
print ('Format %s not recognized' % ext)
def writeCSV (self,outfile):
'''
writes data in tableData object to outfile in csv format
Values with commas are quoted.
'''
import csv
self._outTest(outfile)
with open(outfile, mode='w', newline='', encoding='utf-8') as csvfile:
out = csv.writer(csvfile, dialect='excel')
for r in range(0, self.nrows()):
row=self.table[r]
out.writerow(row)
self.verbose ('csv written to %s' % outfile)
def writeXML (self,out):
'''
writes table data to file out in xml format
'''
import xml.etree.ElementTree as ET
from xml.sax.saxutils import escape
root = ET.Element("tdx") #table data xml
self._outTest(out)
def _indent(elem, level=0):
i = "\n" + level*" "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
_indent(elem, level+1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
#don't need cnames here, so start at 1, but then write all columns in first row
for r in range(1, self.nrows()):
doc = ET.SubElement(root, "row")
for c in range(0, self.ncols()):
cell = self.cell(c,r)
#print ('x,y: %i/%i: %s->%s ' % (r, c, self.columns[c], cell))
#for round trip I need empty cells, at least in the first row
if cell or r == 1:
ET.SubElement(doc, self.table[0][c]).text=escape(str(cell))
tree = ET.ElementTree(root)
_indent(root)
tree.write(out, encoding='UTF-8', xml_declaration=True)
self.verbose ('xml written to %s' % out)
def writeJSON (self, out):
'''
Writes table data in json to file out
JSON doesn't have date type, hence default=str
'''
import json
self._outTest(out)
f = open(out, 'w')
with f as outfile:
json.dump(self.table, outfile, default=str)
self.verbose ('json written to %s' % out)
if __name__ == '__main__': pass
| 31.507157 | 130 | 0.541247 | [
"Apache-2.0"
] | mokko/Py-TableData | TableData.py | 15,407 | Python |
# Copyright 2013-2019 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class Prank(Package):
"""A powerful multiple sequence alignment browser."""
homepage = "http://wasabiapp.org/software/prank/"
url = "http://wasabiapp.org/download/prank/prank.source.170427.tgz"
version('170427', sha256='623eb5e9b5cb0be1f49c3bf715e5fabceb1059b21168437264bdcd5c587a8859')
depends_on('mafft')
depends_on('exonerate')
depends_on('bpp-suite') # for bppancestor
conflicts('%[email protected]', when='@:150803')
def install(self, spec, prefix):
with working_dir('src'):
filter_file('gcc', '{0}'.format(spack_cc),
'Makefile', string=True)
filter_file('g++', '{0}'.format(spack_cxx),
'Makefile', string=True)
if not spec.target.family == 'x86_64':
filter_file('-m64', '', 'Makefile', string=True)
filter_file('-pipe', '', 'Makefile', string=True)
make()
mkdirp(prefix.bin)
install('prank', prefix.bin)
| 34.277778 | 96 | 0.613452 | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | CreRecombinase/spack | var/spack/repos/builtin/packages/prank/package.py | 1,234 | Python |
import pytest
import math
import os
import sys
module_dir = os.path.dirname(__file__)
sys.path.append(os.path.join(module_dir, '..', 'intervalpy'))
from intervalpy import Interval
def test_intersection():
# closed, closed
d1 = Interval(0, 2, start_open=False, end_open=False)
d2 = Interval(1, 3, start_open=False, end_open=False)
assert d1.contains(0)
assert d1.contains(1)
assert d1.contains(2)
d = Interval.intersection([d1, d2])
assert d.start == 1
assert d.end == 2
assert not d.start_open
assert not d.end_open
d = Interval.union([d1, d2])
assert d.start == 0
assert d.end == 3
assert not d.start_open
assert not d.end_open
# closed, open
d1 = Interval(0, 2, start_open=False, end_open=False)
d2 = Interval(1, 3, start_open=True, end_open=True)
d = Interval.intersection([d1, d2])
assert d.start == 1
assert d.end == 2
assert d.start_open
assert not d.end_open
d = Interval.union([d1, d2])
assert d.start == 0
assert d.end == 3
assert not d.start_open
assert d.end_open
# open, open
d1 = Interval(0, 2, start_open=True, end_open=True)
d2 = Interval(1, 3, start_open=True, end_open=True)
assert not d1.contains(0)
assert d1.contains(1)
assert not d1.contains(2)
d = Interval.intersection([d1, d2])
assert d.start == 1
assert d.end == 2
assert d.start_open
assert d.end_open
d = Interval.union([d1, d2])
assert d.start == 0
assert d.end == 3
assert d.start_open
assert d.end_open
d = Interval.intersection([Interval(0, 1), Interval(2, 3)])
assert d.is_empty
d = Interval.intersection([Interval(0, 1, end_open=True), Interval(1, 3, start_open=True)])
assert d.is_empty
d = Interval.intersection([Interval(0, 1), Interval.empty()])
assert d.is_empty
d = Interval.union([Interval.empty(), 1])
assert d.start == 1
assert d.end == 1
def test_interval_contains_inf():
inf = Interval.infinite()
assert inf.contains(math.inf) is True
assert inf.contains(-math.inf) is True
assert Interval.gte(0).contains(math.inf) is True
assert Interval.gte(0).contains(-math.inf) is False
assert Interval.lte(0).contains(math.inf) is False
assert Interval.lte(0).contains(-math.inf) is True
def test_intersection_inf():
assert Interval.intersection([Interval.gte(100), (98, 101)]) == (100, 101)
assert Interval.intersection([Interval.point(100), Interval.open_closed(100, 101)]) == Interval.empty()
def test_cast():
assert bool(Interval.empty()) is False
assert bool(Interval(0, 0)) is True
assert list(Interval.empty()) == []
assert list(Interval(0, 0)) == [0, 0]
assert list(Interval.open(1, 20)) == [1, 20]
def test_intersects():
assert Interval.closed(1, 3).intersects(Interval.closed(2, 3))
assert Interval.closed(1, 3).intersects((2, 3))
assert Interval.closed(1, 3).intersects((1, 3))
assert Interval.closed(1, 3).intersects(Interval.open(1, 3))
assert Interval.closed(1, 3).intersects(Interval.closed(3, 4))
assert not Interval.closed(1, 3).intersects(Interval.open(3, 4))
assert not Interval.open(1, 3).intersects(Interval.closed(3, 4))
assert Interval.point(3).intersects(Interval.closed(3, 4))
assert Interval.point(3).intersects(Interval.closed(1, 3))
assert not Interval.point(3).intersects(Interval.open(3, 4))
assert not Interval.point(3).intersects(Interval.open(1, 3))
assert Interval.closed(1, 3).intersects(Interval.closed(0, 1))
assert not Interval.closed(1, 3).intersects(Interval.open(0, 1))
assert not Interval.open(1, 3).intersects(Interval.closed(0, 1))
assert not Interval.closed(1, 3).intersects(Interval.closed(4, 5))
assert not Interval.closed(1, 3).intersects(Interval.closed(-2, 0))
assert not Interval.closed(1, 3).intersects(Interval.empty())
assert Interval.closed(1, 3).intersects(Interval.infinite())
assert not Interval.point(1).intersects(Interval.open_closed(1, 2))
def test_parse():
d = Interval.parse(Interval(0, 1, start_open=True, end_open=True))
assert d.start == 0
assert d.end == 1
assert d.start_open
assert d.end_open
d = Interval.parse((0, 1))
assert d.start == 0
assert d.end == 1
assert not d.start_open
assert not d.end_open
d = Interval.parse(1)
assert d.start == 1
assert d.end == 1
assert not d.start_open
assert not d.end_open
with pytest.raises(Exception):
_ = Interval.parse(None)
with pytest.raises(Exception):
_ = Interval.parse(None, default_inf=False)
assert Interval.parse(None, default_inf=True) == Interval.infinite()
d = Interval.parse(math.inf)
assert math.isinf(d.start)
assert math.isinf(d.end)
assert d.start > 0
assert d.end > 0
assert not d.is_negative_infinite
assert not d.is_positive_infinite
d = Interval.parse(-math.inf)
assert math.isinf(d.start)
assert math.isinf(d.end)
assert d.start < 0
assert d.end < 0
assert not d.is_negative_infinite
assert not d.is_positive_infinite
d = Interval.parse([])
assert d.is_empty
def test_partition():
ds = Interval(1, 3).partition([2])
assert list(map(tuple, ds)) == [(1, 2), (2, 3)]
assert not ds[0].start_open
assert ds[0].end_open
assert not ds[1].start_open
assert not ds[1].end_open
ds = Interval(0, 3).partition([0, 1, 2, 3, 4], start_open=True)
assert list(map(tuple, ds)) == [(0, 0), (0, 1), (1, 2), (2, 3)]
assert not ds[0].start_open
assert not ds[0].end_open
assert ds[1].start_open
assert not ds[1].end_open
ds = Interval(0, 3).partition([0, 1, 2, 3, 4], start_open=False)
assert list(map(tuple, ds)) == [(0, 1), (1, 2), (2, 3), (3, 3)]
assert not ds[0].start_open
assert ds[0].end_open
assert not ds[1].start_open
assert ds[1].end_open
def test_subset():
d = Interval(1, 3)
assert d.is_subset_of((0, 4))
assert d.is_subset_of((1, 3))
assert not d.is_subset_of(Interval.closed_open(1, 3))
assert d.is_superset_of((2, 2))
assert d.is_superset_of((1, 3))
assert d.is_superset_of(Interval.closed_open(1, 3))
def test_equals():
d = Interval(1, 3)
assert d.equals((1, 3))
assert not d.equals(None)
assert not d.equals(Interval.closed_open(1, 3))
assert Interval.empty().equals(Interval.empty())
# Empty intervals are always equal
assert Interval.open(1, 1).equals(Interval.open(2, 2))
assert Interval.infinite().equals(Interval.infinite())
def test_infinite():
assert Interval.gte(math.inf).is_empty is True
assert Interval.gte(-math.inf).is_empty is False
assert Interval.lte(math.inf).is_empty is False
assert Interval.lte(-math.inf).is_empty is True
def test_round():
assert Interval(1.2, 3.4).round() == (1, 3)
assert Interval(1.2, 3.4).round(method=math.floor) == (1, 3)
assert Interval(1.2, 3.4).round(method=math.ceil) == (2, 4)
assert Interval.open_closed(1.2, 3.4).round() == Interval.open_closed(1, 3)
assert Interval.closed_open(1.2, 3.4).round() == Interval.closed_open(1, 3)
assert Interval.empty().round() == Interval.empty()
def test_extensions():
d = Interval(1, 3)
assert d.get_lte().equals(Interval.lte(3))
assert d.get_gte().equals(Interval.gte(1))
assert d.get_lt().equals(Interval.lt(1))
assert d.get_gt().equals(Interval.gt(3))
d = Interval.open(1, 3)
assert d.get_lte().equals(Interval.lt(3))
assert d.get_gte().equals(Interval.gt(1))
assert d.get_lt().equals(Interval.lte(1))
assert d.get_gt().equals(Interval.gte(3))
d = Interval.empty()
assert d.get_lte().is_empty
assert d.get_gte().is_empty
assert d.get_lt().is_empty
assert d.get_gt().is_empty
def test_inequalities():
assert Interval(1, 3) == (1, 3)
assert (1, 3) == Interval(1, 3)
assert Interval(1, 3) < (4, 6)
assert not Interval(1, 3) < (3, 6)
assert not Interval(1, 3) < (-3, -1)
assert Interval(1, 3) <= (3, 6)
assert Interval(1, 3) <= (2, 6)
assert Interval(1, 3) <= (1, 6)
assert Interval(3, 5) <= (1, 6)
assert not Interval(1, 3) <= (-3, -1)
assert not Interval(3, 6) <= Interval.open(1, 6)
assert Interval(1, 3) < Interval.empty()
assert Interval(1, 3) <= Interval.empty()
assert Interval(7, 9) > (4, 6)
assert not Interval(7, 9) > (4, 7)
assert not Interval(7, 9) > (10, 12)
assert Interval(7, 9) >= (4, 7)
assert Interval(7, 9) >= (4, 8)
assert Interval(7, 9) >= (4, 9)
assert not Interval(7, 9) >= (10, 12)
assert not Interval(4, 10) >= Interval.open(4, 9)
assert Interval(7, 9) > Interval.empty()
assert Interval(7, 9) >= Interval.empty()
def test_arithmetic():
assert Interval(1, 3) + (2, 4) == (1, 4)
assert (1, 3) + Interval(2, 4) == (1, 4)
assert Interval.open(1, 3) + (2, 4) == Interval.open_closed(1, 4)
assert (1, 3) + Interval.open(2, 4) == Interval.closed_open(1, 4)
| 32.263345 | 107 | 0.647695 | [
"MIT"
] | diatche/interval-util-py | test/interval_test.py | 9,066 | Python |
#ABC026f
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
| 15.2 | 28 | 0.789474 | [
"Unlicense"
] | VolgaKurvar/AtCoder | ABC026/ABC026f.py | 76 | Python |
from setuptools import setup, find_packages
version = "2.5.4"
setup(
include_package_data=True,
name="metaflow",
version=version,
description="Metaflow: More Data Science, Less Engineering",
long_description=open("README.md").read(),
long_description_content_type="text/markdown",
author="Machine Learning Infrastructure Team at Netflix",
author_email="[email protected]",
license="Apache License 2.0",
packages=find_packages(exclude=["metaflow_test"]),
py_modules=[
"metaflow",
],
package_data={"metaflow": ["tutorials/*/*"]},
entry_points="""
[console_scripts]
metaflow=metaflow.main_cli:main
""",
install_requires=[
"requests",
"boto3",
"pylint",
],
)
| 25.833333 | 64 | 0.645161 | [
"Apache-2.0"
] | jinnovation/metaflow | setup.py | 775 | Python |
#!/usr/bin/env python
import glob
import re
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-c", "--calctime", dest="calctime", type=int, default=1400)
parser.add_option("-s", "--startdate", dest="startdate", type=int)
parser.add_option("-r", "--rootdir", dest="rootdir", default="/apps/multex/trade/run/live-prod")
(options, args) = parser.parse_args()
directories = glob.glob(options.rootdir + "/2010/*/*/calcres")
directories.sort()
for adir in directories:
fs = [g for g in glob.glob(adir + "/calcres.*.txt.gz")]
fs.sort()
found = False
for file in fs:
if found: continue
match = re.search('.*calcres\.(\d+)_(\d+)\.txt\.gz', file)
if match:
if float(match.group(1)) > options.startdate and float(match.group(2)) > options.calctime:
print file
found = True
| 30.310345 | 102 | 0.632537 | [
"BSD-3-Clause"
] | Kaffeegangster/ml_monorepo | statarb/src/python/bin/get_calcres_files.py | 879 | Python |
# coding: utf-8
"""
Cherwell REST API
Unofficial Python Cherwell REST API library. # noqa: E501
The version of the OpenAPI document: 9.3.2
Contact: See AUTHORS.
Generated by: https://openapi-generator.tech
"""
from __future__ import absolute_import
import re # noqa: F401
# python 2 and python 3 compatibility library
import six
from pycherwell.api_client import ApiClient
from pycherwell.exceptions import (
ApiTypeError,
ApiValueError
)
class TeamsApi(object):
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def teams_add_user_to_team_by_batch_v1(self, add_user_to_team_by_batch_request, **kwargs): # noqa: E501
"""Add users to a team by batch # noqa: E501
Operation to add users to a Team by batch. To get internal IDs for users, use “Get User Information in a Batch.” To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_add_user_to_team_by_batch_v1(add_user_to_team_by_batch_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddUserToTeamByBatchRequest add_user_to_team_by_batch_request: Request object to specify a list of add user to team request objects. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: AddUserToTeamByBatchResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_add_user_to_team_by_batch_v1_with_http_info(add_user_to_team_by_batch_request, **kwargs) # noqa: E501
def teams_add_user_to_team_by_batch_v1_with_http_info(self, add_user_to_team_by_batch_request, **kwargs): # noqa: E501
"""Add users to a team by batch # noqa: E501
Operation to add users to a Team by batch. To get internal IDs for users, use “Get User Information in a Batch.” To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_add_user_to_team_by_batch_v1_with_http_info(add_user_to_team_by_batch_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddUserToTeamByBatchRequest add_user_to_team_by_batch_request: Request object to specify a list of add user to team request objects. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(AddUserToTeamByBatchResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['add_user_to_team_by_batch_request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_add_user_to_team_by_batch_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'add_user_to_team_by_batch_request' is set
if self.api_client.client_side_validation and ('add_user_to_team_by_batch_request' not in local_var_params or # noqa: E501
local_var_params['add_user_to_team_by_batch_request'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `add_user_to_team_by_batch_request` when calling `teams_add_user_to_team_by_batch_v1`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'add_user_to_team_by_batch_request' in local_var_params:
body_params = local_var_params['add_user_to_team_by_batch_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/addusertoteambybatch', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='AddUserToTeamByBatchResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_add_user_to_team_v1(self, add_user_to_team_request, **kwargs): # noqa: E501
"""Add a user to a team # noqa: E501
Operation to add a user to a Team. To get the user's internal ID, use \"Get a user by login ID\" or \"Get a user by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_add_user_to_team_v1(add_user_to_team_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddUserToTeamRequest add_user_to_team_request: Request object to specify user and team values. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_add_user_to_team_v1_with_http_info(add_user_to_team_request, **kwargs) # noqa: E501
def teams_add_user_to_team_v1_with_http_info(self, add_user_to_team_request, **kwargs): # noqa: E501
"""Add a user to a team # noqa: E501
Operation to add a user to a Team. To get the user's internal ID, use \"Get a user by login ID\" or \"Get a user by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_add_user_to_team_v1_with_http_info(add_user_to_team_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddUserToTeamRequest add_user_to_team_request: Request object to specify user and team values. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['add_user_to_team_request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_add_user_to_team_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'add_user_to_team_request' is set
if self.api_client.client_side_validation and ('add_user_to_team_request' not in local_var_params or # noqa: E501
local_var_params['add_user_to_team_request'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `add_user_to_team_request` when calling `teams_add_user_to_team_v1`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'add_user_to_team_request' in local_var_params:
body_params = local_var_params['add_user_to_team_request']
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/addusertoteam', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_add_user_to_team_v2(self, add_user_to_team_request, **kwargs): # noqa: E501
"""Add a user to a team # noqa: E501
Operation to add a user to a Team. To get the user's internal ID, use \"Get a user by login ID\" or \"Get a user by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_add_user_to_team_v2(add_user_to_team_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddUserToTeamRequest add_user_to_team_request: Request object to specify user and team values. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: AddUserToTeamResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_add_user_to_team_v2_with_http_info(add_user_to_team_request, **kwargs) # noqa: E501
def teams_add_user_to_team_v2_with_http_info(self, add_user_to_team_request, **kwargs): # noqa: E501
"""Add a user to a team # noqa: E501
Operation to add a user to a Team. To get the user's internal ID, use \"Get a user by login ID\" or \"Get a user by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_add_user_to_team_v2_with_http_info(add_user_to_team_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddUserToTeamRequest add_user_to_team_request: Request object to specify user and team values. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(AddUserToTeamResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['add_user_to_team_request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_add_user_to_team_v2" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'add_user_to_team_request' is set
if self.api_client.client_side_validation and ('add_user_to_team_request' not in local_var_params or # noqa: E501
local_var_params['add_user_to_team_request'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `add_user_to_team_request` when calling `teams_add_user_to_team_v2`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'add_user_to_team_request' in local_var_params:
body_params = local_var_params['add_user_to_team_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V2/addusertoteam', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='AddUserToTeamResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_delete_team_v1(self, teamid, **kwargs): # noqa: E501
"""Delete a Team # noqa: E501
Operation to delete a Team by Team ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_delete_team_v1(teamid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str teamid: Specify the Team ID. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_delete_team_v1_with_http_info(teamid, **kwargs) # noqa: E501
def teams_delete_team_v1_with_http_info(self, teamid, **kwargs): # noqa: E501
"""Delete a Team # noqa: E501
Operation to delete a Team by Team ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_delete_team_v1_with_http_info(teamid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str teamid: Specify the Team ID. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['teamid'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_delete_team_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'teamid' is set
if self.api_client.client_side_validation and ('teamid' not in local_var_params or # noqa: E501
local_var_params['teamid'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `teamid` when calling `teams_delete_team_v1`") # noqa: E501
collection_formats = {}
path_params = {}
if 'teamid' in local_var_params:
path_params['teamid'] = local_var_params['teamid'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/deleteteam/{teamid}', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_get_team_v1(self, teamid, **kwargs): # noqa: E501
"""Get a team by its TeamId # noqa: E501
Operation to get Team Info for a single Team using its Team ID. To get a Team's internal ID, use \"Get all available Teams.\" Note that TeamType has two possible values, where TeamType = 0 for User (CSM Users), or TeamType = 1 for Workgroup (CSM Customers). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_team_v1(teamid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str teamid: The Team ID of the Team to get. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_get_team_v1_with_http_info(teamid, **kwargs) # noqa: E501
def teams_get_team_v1_with_http_info(self, teamid, **kwargs): # noqa: E501
"""Get a team by its TeamId # noqa: E501
Operation to get Team Info for a single Team using its Team ID. To get a Team's internal ID, use \"Get all available Teams.\" Note that TeamType has two possible values, where TeamType = 0 for User (CSM Users), or TeamType = 1 for Workgroup (CSM Customers). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_team_v1_with_http_info(teamid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str teamid: The Team ID of the Team to get. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['teamid'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_get_team_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'teamid' is set
if self.api_client.client_side_validation and ('teamid' not in local_var_params or # noqa: E501
local_var_params['teamid'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `teamid` when calling `teams_get_team_v1`") # noqa: E501
collection_formats = {}
path_params = {}
if 'teamid' in local_var_params:
path_params['teamid'] = local_var_params['teamid'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/getteam/{teamid}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_get_teams_v1(self, **kwargs): # noqa: E501
"""Get all available Teams # noqa: E501
Operation to get IDs and names for all available Teams. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_teams_v1(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamsResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_get_teams_v1_with_http_info(**kwargs) # noqa: E501
def teams_get_teams_v1_with_http_info(self, **kwargs): # noqa: E501
"""Get all available Teams # noqa: E501
Operation to get IDs and names for all available Teams. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_teams_v1_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamsResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_get_teams_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/getteams', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamsResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_get_teams_v2(self, **kwargs): # noqa: E501
"""Get all available Teams # noqa: E501
Operation to get IDs and names for all available Teams. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_teams_v2(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamsV2Response
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_get_teams_v2_with_http_info(**kwargs) # noqa: E501
def teams_get_teams_v2_with_http_info(self, **kwargs): # noqa: E501
"""Get all available Teams # noqa: E501
Operation to get IDs and names for all available Teams. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_teams_v2_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamsV2Response, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_get_teams_v2" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V2/getteams', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamsV2Response', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_get_users_teams_v1(self, user_record_id, **kwargs): # noqa: E501
"""Get Team assignments for a user # noqa: E501
Operation to get Team assignments for a user. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public id.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_users_teams_v1(user_record_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str user_record_id: Specify the user record ID. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamsResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_get_users_teams_v1_with_http_info(user_record_id, **kwargs) # noqa: E501
def teams_get_users_teams_v1_with_http_info(self, user_record_id, **kwargs): # noqa: E501
"""Get Team assignments for a user # noqa: E501
Operation to get Team assignments for a user. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public id.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_users_teams_v1_with_http_info(user_record_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str user_record_id: Specify the user record ID. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamsResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['user_record_id'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_get_users_teams_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'user_record_id' is set
if self.api_client.client_side_validation and ('user_record_id' not in local_var_params or # noqa: E501
local_var_params['user_record_id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `user_record_id` when calling `teams_get_users_teams_v1`") # noqa: E501
collection_formats = {}
path_params = {}
if 'user_record_id' in local_var_params:
path_params['userRecordId'] = local_var_params['user_record_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/getusersteams/userrecordid/{userRecordId}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamsResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_get_users_teams_v2(self, user_record_id, **kwargs): # noqa: E501
"""Get Team assignments for a user # noqa: E501
Operation to get Team assignments for a user. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public id.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_users_teams_v2(user_record_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str user_record_id: Specify the user record ID. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamsV2Response
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_get_users_teams_v2_with_http_info(user_record_id, **kwargs) # noqa: E501
def teams_get_users_teams_v2_with_http_info(self, user_record_id, **kwargs): # noqa: E501
"""Get Team assignments for a user # noqa: E501
Operation to get Team assignments for a user. To get record IDs, use \"Get a user by login ID\" or \"Get a user by public id.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_users_teams_v2_with_http_info(user_record_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str user_record_id: Specify the user record ID. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamsV2Response, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['user_record_id'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_get_users_teams_v2" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'user_record_id' is set
if self.api_client.client_side_validation and ('user_record_id' not in local_var_params or # noqa: E501
local_var_params['user_record_id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `user_record_id` when calling `teams_get_users_teams_v2`") # noqa: E501
collection_formats = {}
path_params = {}
if 'user_record_id' in local_var_params:
path_params['userRecordId'] = local_var_params['user_record_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V2/getusersteams/userrecordid/{userRecordId}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamsV2Response', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_get_workgroups_v1(self, **kwargs): # noqa: E501
"""Get all available Workgroups # noqa: E501
Operation to get IDs and names for all available Workgroups. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_workgroups_v1(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamsResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_get_workgroups_v1_with_http_info(**kwargs) # noqa: E501
def teams_get_workgroups_v1_with_http_info(self, **kwargs): # noqa: E501
"""Get all available Workgroups # noqa: E501
Operation to get IDs and names for all available Workgroups. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_workgroups_v1_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamsResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_get_workgroups_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/getworkgroups', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamsResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_get_workgroups_v2(self, **kwargs): # noqa: E501
"""Get all available Workgroups # noqa: E501
Operation to get IDs and names for all available Workgroups. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_workgroups_v2(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamsV2Response
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_get_workgroups_v2_with_http_info(**kwargs) # noqa: E501
def teams_get_workgroups_v2_with_http_info(self, **kwargs): # noqa: E501
"""Get all available Workgroups # noqa: E501
Operation to get IDs and names for all available Workgroups. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_get_workgroups_v2_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamsV2Response, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_get_workgroups_v2" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V2/getworkgroups', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamsV2Response', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_remove_customer_from_workgroup_v1(self, workgroupid, customerrecordid, **kwargs): # noqa: E501
"""Remove a customer from a Workgroup # noqa: E501
Operation to remove a Customer from a Workgroup. To remove, specify the Workgroup ID and the Customer Record ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_remove_customer_from_workgroup_v1(workgroupid, customerrecordid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str workgroupid: Specify the Workgroup ID. (required)
:param str customerrecordid: Specify the Customer record ID. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: RemoveCustomerFromWorkgroupResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_remove_customer_from_workgroup_v1_with_http_info(workgroupid, customerrecordid, **kwargs) # noqa: E501
def teams_remove_customer_from_workgroup_v1_with_http_info(self, workgroupid, customerrecordid, **kwargs): # noqa: E501
"""Remove a customer from a Workgroup # noqa: E501
Operation to remove a Customer from a Workgroup. To remove, specify the Workgroup ID and the Customer Record ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_remove_customer_from_workgroup_v1_with_http_info(workgroupid, customerrecordid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str workgroupid: Specify the Workgroup ID. (required)
:param str customerrecordid: Specify the Customer record ID. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(RemoveCustomerFromWorkgroupResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['workgroupid', 'customerrecordid'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_remove_customer_from_workgroup_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'workgroupid' is set
if self.api_client.client_side_validation and ('workgroupid' not in local_var_params or # noqa: E501
local_var_params['workgroupid'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `workgroupid` when calling `teams_remove_customer_from_workgroup_v1`") # noqa: E501
# verify the required parameter 'customerrecordid' is set
if self.api_client.client_side_validation and ('customerrecordid' not in local_var_params or # noqa: E501
local_var_params['customerrecordid'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `customerrecordid` when calling `teams_remove_customer_from_workgroup_v1`") # noqa: E501
collection_formats = {}
path_params = {}
if 'workgroupid' in local_var_params:
path_params['workgroupid'] = local_var_params['workgroupid'] # noqa: E501
if 'customerrecordid' in local_var_params:
path_params['customerrecordid'] = local_var_params['customerrecordid'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/removecustomerfromworkgroup/workgroupid/{workgroupid}/customerrecordid/{customerrecordid}', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='RemoveCustomerFromWorkgroupResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_remove_user_from_team_v1(self, team_id, userrecordid, **kwargs): # noqa: E501
"""Operation to remove a User from a Team. # noqa: E501
Operation to remove a User from a Team. To get the User's record ID, use \"Get a User by login ID\" or \"Get a User by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_remove_user_from_team_v1(team_id, userrecordid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str team_id: Specify the internal ID of the Team. (required)
:param str userrecordid: Specify the record ID of the User to remove. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_remove_user_from_team_v1_with_http_info(team_id, userrecordid, **kwargs) # noqa: E501
def teams_remove_user_from_team_v1_with_http_info(self, team_id, userrecordid, **kwargs): # noqa: E501
"""Operation to remove a User from a Team. # noqa: E501
Operation to remove a User from a Team. To get the User's record ID, use \"Get a User by login ID\" or \"Get a User by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_remove_user_from_team_v1_with_http_info(team_id, userrecordid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str team_id: Specify the internal ID of the Team. (required)
:param str userrecordid: Specify the record ID of the User to remove. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['team_id', 'userrecordid'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_remove_user_from_team_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'team_id' is set
if self.api_client.client_side_validation and ('team_id' not in local_var_params or # noqa: E501
local_var_params['team_id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `team_id` when calling `teams_remove_user_from_team_v1`") # noqa: E501
# verify the required parameter 'userrecordid' is set
if self.api_client.client_side_validation and ('userrecordid' not in local_var_params or # noqa: E501
local_var_params['userrecordid'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `userrecordid` when calling `teams_remove_user_from_team_v1`") # noqa: E501
collection_formats = {}
path_params = {}
if 'team_id' in local_var_params:
path_params['teamId'] = local_var_params['team_id'] # noqa: E501
if 'userrecordid' in local_var_params:
path_params['userrecordid'] = local_var_params['userrecordid'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/removeuserfromteam/teamid/{teamId}/userrecordid/{userrecordid}', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_remove_user_from_team_v2(self, team_id, userrecordid, **kwargs): # noqa: E501
"""Operation to remove a User from a Team. # noqa: E501
Operation to remove a User from a Team. To get the User's record ID, use \"Get a User by login ID\" or \"Get a User by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_remove_user_from_team_v2(team_id, userrecordid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str team_id: Specify the internal ID of the Team. (required)
:param str userrecordid: Specify the record ID of the User to remove. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: RemoveUserFromTeamResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_remove_user_from_team_v2_with_http_info(team_id, userrecordid, **kwargs) # noqa: E501
def teams_remove_user_from_team_v2_with_http_info(self, team_id, userrecordid, **kwargs): # noqa: E501
"""Operation to remove a User from a Team. # noqa: E501
Operation to remove a User from a Team. To get the User's record ID, use \"Get a User by login ID\" or \"Get a User by public ID.\" To get a Team's internal ID, use \"Get all available Teams.\" # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_remove_user_from_team_v2_with_http_info(team_id, userrecordid, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str team_id: Specify the internal ID of the Team. (required)
:param str userrecordid: Specify the record ID of the User to remove. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(RemoveUserFromTeamResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['team_id', 'userrecordid'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_remove_user_from_team_v2" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'team_id' is set
if self.api_client.client_side_validation and ('team_id' not in local_var_params or # noqa: E501
local_var_params['team_id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `team_id` when calling `teams_remove_user_from_team_v2`") # noqa: E501
# verify the required parameter 'userrecordid' is set
if self.api_client.client_side_validation and ('userrecordid' not in local_var_params or # noqa: E501
local_var_params['userrecordid'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `userrecordid` when calling `teams_remove_user_from_team_v2`") # noqa: E501
collection_formats = {}
path_params = {}
if 'team_id' in local_var_params:
path_params['teamId'] = local_var_params['team_id'] # noqa: E501
if 'userrecordid' in local_var_params:
path_params['userrecordid'] = local_var_params['userrecordid'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V2/removeuserfromteam/teamid/{teamId}/userrecordid/{userrecordid}', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='RemoveUserFromTeamResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_save_team_member_v1(self, save_team_member_request, **kwargs): # noqa: E501
"""Add or Update a team member # noqa: E501
Operation to add or update a Team Member. To add or update, specify User ID, Team ID, and if Team Manager. Optionally, set the Team as the User's default Team. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_save_team_member_v1(save_team_member_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param SaveTeamMemberRequest save_team_member_request: The request object to add or update a Team Member. User recID specifies the User to add or update. TeamId specifies the Team to update. IsTeamManager specifies whether the User is a Team Manager, and SetAsDefaultTeam specifies whether to set this Team as the User's default team. UserRecId, TeamId, and IsTeamManager are required. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: SaveTeamMemberResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_save_team_member_v1_with_http_info(save_team_member_request, **kwargs) # noqa: E501
def teams_save_team_member_v1_with_http_info(self, save_team_member_request, **kwargs): # noqa: E501
"""Add or Update a team member # noqa: E501
Operation to add or update a Team Member. To add or update, specify User ID, Team ID, and if Team Manager. Optionally, set the Team as the User's default Team. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_save_team_member_v1_with_http_info(save_team_member_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param SaveTeamMemberRequest save_team_member_request: The request object to add or update a Team Member. User recID specifies the User to add or update. TeamId specifies the Team to update. IsTeamManager specifies whether the User is a Team Manager, and SetAsDefaultTeam specifies whether to set this Team as the User's default team. UserRecId, TeamId, and IsTeamManager are required. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(SaveTeamMemberResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['save_team_member_request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_save_team_member_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'save_team_member_request' is set
if self.api_client.client_side_validation and ('save_team_member_request' not in local_var_params or # noqa: E501
local_var_params['save_team_member_request'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `save_team_member_request` when calling `teams_save_team_member_v1`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'save_team_member_request' in local_var_params:
body_params = local_var_params['save_team_member_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/saveteammember', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='SaveTeamMemberResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_save_team_v1(self, team_save_request, **kwargs): # noqa: E501
"""Create or update a team # noqa: E501
Operation to create or update a Team or Workgroup. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_save_team_v1(team_save_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param TeamSaveRequest team_save_request: Request object to create Teams or Workgroups. To create a Team, use teamType and teamName. To update a team, use teamID. Team type values must be User or CustomerWorkgroup. The teamType cannot be changed for existing Teams or Workgroups. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: TeamSaveResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_save_team_v1_with_http_info(team_save_request, **kwargs) # noqa: E501
def teams_save_team_v1_with_http_info(self, team_save_request, **kwargs): # noqa: E501
"""Create or update a team # noqa: E501
Operation to create or update a Team or Workgroup. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_save_team_v1_with_http_info(team_save_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param TeamSaveRequest team_save_request: Request object to create Teams or Workgroups. To create a Team, use teamType and teamName. To update a team, use teamID. Team type values must be User or CustomerWorkgroup. The teamType cannot be changed for existing Teams or Workgroups. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TeamSaveResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['team_save_request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_save_team_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'team_save_request' is set
if self.api_client.client_side_validation and ('team_save_request' not in local_var_params or # noqa: E501
local_var_params['team_save_request'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `team_save_request` when calling `teams_save_team_v1`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'team_save_request' in local_var_params:
body_params = local_var_params['team_save_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/saveteam', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TeamSaveResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def teams_save_workgroup_member_v1(self, save_workgroup_member_request, **kwargs): # noqa: E501
"""Save the membership status of a Workgroup member. # noqa: E501
Operation to add or update a Workgroup Member. To add or update, specify Customer Record ID, Workgroup ID, and if Workgroup Manager. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_save_workgroup_member_v1(save_workgroup_member_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param SaveWorkgroupMemberRequest save_workgroup_member_request: The request object to add or update a Workgroup Member. CustomerRecordId specifies the Customer to add or update. WorkgroupId specifies the Workgroup to update. CustomerIsWorkgroupManager specifies whether the Customer is a Workgroup Manager. (required)
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: SaveWorkgroupMemberResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.teams_save_workgroup_member_v1_with_http_info(save_workgroup_member_request, **kwargs) # noqa: E501
def teams_save_workgroup_member_v1_with_http_info(self, save_workgroup_member_request, **kwargs): # noqa: E501
"""Save the membership status of a Workgroup member. # noqa: E501
Operation to add or update a Workgroup Member. To add or update, specify Customer Record ID, Workgroup ID, and if Workgroup Manager. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.teams_save_workgroup_member_v1_with_http_info(save_workgroup_member_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param SaveWorkgroupMemberRequest save_workgroup_member_request: The request object to add or update a Workgroup Member. CustomerRecordId specifies the Customer to add or update. WorkgroupId specifies the Workgroup to update. CustomerIsWorkgroupManager specifies whether the Customer is a Workgroup Manager. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(SaveWorkgroupMemberResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['save_workgroup_member_request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method teams_save_workgroup_member_v1" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'save_workgroup_member_request' is set
if self.api_client.client_side_validation and ('save_workgroup_member_request' not in local_var_params or # noqa: E501
local_var_params['save_workgroup_member_request'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `save_workgroup_member_request` when calling `teams_save_workgroup_member_v1`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'save_workgroup_member_request' in local_var_params:
body_params = local_var_params['save_workgroup_member_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/V1/saveworkgroupmember', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='SaveWorkgroupMemberResponse', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
| 50.182012 | 404 | 0.62053 | [
"Apache-2.0"
] | greenpau/pycherwell | pycherwell/api/teams_api.py | 94,300 | Python |
#!/usr/bin/env python3
# Copyright (c) 2014-2016 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Base class for RPC testing."""
from collections import deque
from enum import Enum
import logging
import optparse
import os
import pdb
import shutil
import sys
import tempfile
import time
import traceback
from .authproxy import JSONRPCException
from . import coverage
from .test_node import TestNode
from .util import (
MAX_NODES,
PortSeed,
assert_equal,
check_json_precision,
connect_nodes_bi,
disconnect_nodes,
initialize_datadir,
log_filename,
p2p_port,
set_node_times,
sync_blocks,
sync_mempools,
)
class TestStatus(Enum):
PASSED = 1
FAILED = 2
SKIPPED = 3
TEST_EXIT_PASSED = 0
TEST_EXIT_FAILED = 1
TEST_EXIT_SKIPPED = 77
BITCOIND_PROC_WAIT_TIMEOUT = 60
class BitcoinTestFramework(object):
"""Base class for a bitcoin test script.
Individual bitcoin test scripts should subclass this class and override the following methods:
- __init__()
- add_options()
- setup_chain()
- setup_network()
- run_test()
The main() method should not be overridden.
This class also contains various public and private helper methods."""
# Methods to override in subclass test scripts.
def __init__(self):
self.num_nodes = 4
self.setup_clean_chain = False
self.nodes = []
self.mocktime = 0
def add_options(self, parser):
pass
def setup_chain(self):
self.log.info("Initializing test directory " + self.options.tmpdir)
if self.setup_clean_chain:
self._initialize_chain_clean(self.options.tmpdir, self.num_nodes)
else:
self._initialize_chain(self.options.tmpdir, self.num_nodes, self.options.cachedir)
def setup_network(self):
self.setup_nodes()
# Connect the nodes as a "chain". This allows us
# to split the network between nodes 1 and 2 to get
# two halves that can work on competing chains.
for i in range(self.num_nodes - 1):
connect_nodes_bi(self.nodes, i, i + 1)
self.sync_all()
def setup_nodes(self):
extra_args = None
if hasattr(self, "extra_args"):
extra_args = self.extra_args
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
def run_test(self):
raise NotImplementedError
# Main function. This should not be overridden by the subclass test scripts.
def main(self):
parser = optparse.OptionParser(usage="%prog [options]")
parser.add_option("--nocleanup", dest="nocleanup", default=False, action="store_true",
help="Leave bitcoinds and test.* datadir on exit or error")
parser.add_option("--noshutdown", dest="noshutdown", default=False, action="store_true",
help="Don't stop bitcoinds after the test execution")
parser.add_option("--srcdir", dest="srcdir", default=os.path.normpath(os.path.dirname(os.path.realpath(__file__)) + "/../../../src"),
help="Source directory containing bitcoind/bitcoin-cli (default: %default)")
parser.add_option("--cachedir", dest="cachedir", default=os.path.normpath(os.path.dirname(os.path.realpath(__file__)) + "/../../cache"),
help="Directory for caching pregenerated datadirs")
parser.add_option("--tmpdir", dest="tmpdir", help="Root directory for datadirs")
parser.add_option("-l", "--loglevel", dest="loglevel", default="INFO",
help="log events at this level and higher to the console. Can be set to DEBUG, INFO, WARNING, ERROR or CRITICAL. Passing --loglevel DEBUG will output all logs to console. Note that logs at all levels are always written to the test_framework.log file in the temporary test directory.")
parser.add_option("--tracerpc", dest="trace_rpc", default=False, action="store_true",
help="Print out all RPC calls as they are made")
parser.add_option("--portseed", dest="port_seed", default=os.getpid(), type='int',
help="The seed to use for assigning port numbers (default: current process id)")
parser.add_option("--coveragedir", dest="coveragedir",
help="Write tested RPC commands into this directory")
parser.add_option("--configfile", dest="configfile",
help="Location of the test framework config file")
parser.add_option("--pdbonfailure", dest="pdbonfailure", default=False, action="store_true",
help="Attach a python debugger if test fails")
self.add_options(parser)
(self.options, self.args) = parser.parse_args()
PortSeed.n = self.options.port_seed
os.environ['PATH'] = self.options.srcdir + ":" + self.options.srcdir + "/qt:" + os.environ['PATH']
check_json_precision()
# Set up temp directory and start logging
if self.options.tmpdir:
os.makedirs(self.options.tmpdir, exist_ok=False)
else:
self.options.tmpdir = tempfile.mkdtemp(prefix="test")
self._start_logging()
success = TestStatus.FAILED
try:
self.setup_chain()
self.setup_network()
self.run_test()
success = TestStatus.PASSED
except JSONRPCException as e:
self.log.exception("JSONRPC error")
except SkipTest as e:
self.log.warning("Test Skipped: %s" % e.message)
success = TestStatus.SKIPPED
except AssertionError as e:
self.log.exception("Assertion failed")
except KeyError as e:
self.log.exception("Key error")
except Exception as e:
self.log.exception("Unexpected exception caught during testing")
except KeyboardInterrupt as e:
self.log.warning("Exiting after keyboard interrupt")
if success == TestStatus.FAILED and self.options.pdbonfailure:
print("Testcase failed. Attaching python debugger. Enter ? for help")
pdb.set_trace()
if not self.options.noshutdown:
self.log.info("Stopping nodes")
if self.nodes:
self.stop_nodes()
else:
self.log.info("Note: bitcoinds were not stopped and may still be running")
if not self.options.nocleanup and not self.options.noshutdown and success != TestStatus.FAILED:
self.log.info("Cleaning up")
shutil.rmtree(self.options.tmpdir)
else:
self.log.warning("Not cleaning up dir %s" % self.options.tmpdir)
if os.getenv("PYTHON_DEBUG", ""):
# Dump the end of the debug logs, to aid in debugging rare
# travis failures.
import glob
filenames = [self.options.tmpdir + "/test_framework.log"]
filenames += glob.glob(self.options.tmpdir + "/node*/regtest/debug.log")
MAX_LINES_TO_PRINT = 1000
for fn in filenames:
try:
with open(fn, 'r') as f:
print("From", fn, ":")
print("".join(deque(f, MAX_LINES_TO_PRINT)))
except OSError:
print("Opening file %s failed." % fn)
traceback.print_exc()
if success == TestStatus.PASSED:
self.log.info("Tests successful")
sys.exit(TEST_EXIT_PASSED)
elif success == TestStatus.SKIPPED:
self.log.info("Test skipped")
sys.exit(TEST_EXIT_SKIPPED)
else:
self.log.error("Test failed. Test logging available at %s/test_framework.log", self.options.tmpdir)
logging.shutdown()
sys.exit(TEST_EXIT_FAILED)
# Public helper methods. These can be accessed by the subclass test scripts.
def start_node(self, i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None, stderr=None):
"""Start a bitcoind and return RPC connection to it"""
if extra_args is None:
extra_args = []
if binary is None:
binary = os.getenv("BITCOIND", "bitcoind")
node = TestNode(i, dirname, extra_args, rpchost, timewait, binary, stderr, self.mocktime, coverage_dir=self.options.coveragedir)
node.start()
node.wait_for_rpc_connection()
if self.options.coveragedir is not None:
coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc)
return node
def start_nodes(self, num_nodes, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
"""Start multiple bitcoinds, return RPC connections to them"""
if extra_args is None:
extra_args = [[]] * num_nodes
if binary is None:
binary = [None] * num_nodes
assert_equal(len(extra_args), num_nodes)
assert_equal(len(binary), num_nodes)
nodes = []
try:
for i in range(num_nodes):
nodes.append(TestNode(i, dirname, extra_args[i], rpchost, timewait=timewait, binary=binary[i], stderr=None, mocktime=self.mocktime, coverage_dir=self.options.coveragedir))
nodes[i].start()
for node in nodes:
node.wait_for_rpc_connection()
except:
# If one node failed to start, stop the others
self.stop_nodes()
raise
if self.options.coveragedir is not None:
for node in nodes:
coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc)
return nodes
def stop_node(self, i):
"""Stop a bitcoind test node"""
self.nodes[i].stop_node()
while not self.nodes[i].is_node_stopped():
time.sleep(0.1)
def stop_nodes(self):
"""Stop multiple bitcoind test nodes"""
for node in self.nodes:
# Issue RPC to stop nodes
node.stop_node()
for node in self.nodes:
# Wait for nodes to stop
while not node.is_node_stopped():
time.sleep(0.1)
def assert_start_raises_init_error(self, i, dirname, extra_args=None, expected_msg=None):
with tempfile.SpooledTemporaryFile(max_size=2**16) as log_stderr:
try:
self.start_node(i, dirname, extra_args, stderr=log_stderr)
self.stop_node(i)
except Exception as e:
assert 'bitcoind exited' in str(e) # node must have shutdown
self.nodes[i].running = False
self.nodes[i].process = None
if expected_msg is not None:
log_stderr.seek(0)
stderr = log_stderr.read().decode('utf-8')
if expected_msg not in stderr:
raise AssertionError("Expected error \"" + expected_msg + "\" not found in:\n" + stderr)
else:
if expected_msg is None:
assert_msg = "bitcoind should have exited with an error"
else:
assert_msg = "bitcoind should have exited with expected error " + expected_msg
raise AssertionError(assert_msg)
def wait_for_node_exit(self, i, timeout):
self.nodes[i].process.wait(timeout)
def split_network(self):
"""
Split the network of four nodes into nodes 0/1 and 2/3.
"""
disconnect_nodes(self.nodes[1], 2)
disconnect_nodes(self.nodes[2], 1)
self.sync_all([self.nodes[:2], self.nodes[2:]])
def join_network(self):
"""
Join the (previously split) network halves together.
"""
connect_nodes_bi(self.nodes, 1, 2)
self.sync_all()
def sync_all(self, node_groups=None):
if not node_groups:
node_groups = [self.nodes]
for group in node_groups:
sync_blocks(group)
sync_mempools(group)
def enable_mocktime(self):
"""Enable mocktime for the script.
mocktime may be needed for scripts that use the cached version of the
blockchain. If the cached version of the blockchain is used without
mocktime then the mempools will not sync due to IBD.
For backwared compatibility of the python scripts with previous
versions of the cache, this helper function sets mocktime to Jan 1,
2014 + (201 * 10 * 60)"""
self.mocktime = 1388534400 + (201 * 10 * 60)
def disable_mocktime(self):
self.mocktime = 0
# Private helper methods. These should not be accessed by the subclass test scripts.
def _start_logging(self):
# Add logger and logging handlers
self.log = logging.getLogger('TestFramework')
self.log.setLevel(logging.DEBUG)
# Create file handler to log all messages
fh = logging.FileHandler(self.options.tmpdir + '/test_framework.log')
fh.setLevel(logging.DEBUG)
# Create console handler to log messages to stderr. By default this logs only error messages, but can be configured with --loglevel.
ch = logging.StreamHandler(sys.stdout)
# User can provide log level as a number or string (eg DEBUG). loglevel was caught as a string, so try to convert it to an int
ll = int(self.options.loglevel) if self.options.loglevel.isdigit() else self.options.loglevel.upper()
ch.setLevel(ll)
# Format logs the same as bitcoind's debug.log with microprecision (so log files can be concatenated and sorted)
formatter = logging.Formatter(fmt='%(asctime)s.%(msecs)03d000 %(name)s (%(levelname)s): %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
formatter.converter = time.gmtime
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# add the handlers to the logger
self.log.addHandler(fh)
self.log.addHandler(ch)
if self.options.trace_rpc:
rpc_logger = logging.getLogger("BitcoinRPC")
rpc_logger.setLevel(logging.DEBUG)
rpc_handler = logging.StreamHandler(sys.stdout)
rpc_handler.setLevel(logging.DEBUG)
rpc_logger.addHandler(rpc_handler)
def _initialize_chain(self, test_dir, num_nodes, cachedir):
"""Initialize a pre-mined blockchain for use by the test.
Create a cache of a 200-block-long chain (with wallet) for MAX_NODES
Afterward, create num_nodes copies from the cache."""
assert num_nodes <= MAX_NODES
create_cache = False
for i in range(MAX_NODES):
if not os.path.isdir(os.path.join(cachedir, 'node' + str(i))):
create_cache = True
break
if create_cache:
self.log.debug("Creating data directories from cached datadir")
# find and delete old cache directories if any exist
for i in range(MAX_NODES):
if os.path.isdir(os.path.join(cachedir, "node" + str(i))):
shutil.rmtree(os.path.join(cachedir, "node" + str(i)))
# Create cache directories, run bitcoinds:
for i in range(MAX_NODES):
datadir = initialize_datadir(cachedir, i)
args = [os.getenv("BITCOIND", "bitcoind"), "-server", "-keypool=1", "-datadir=" + datadir, "-discover=0"]
if i > 0:
args.append("-connect=127.0.0.1:" + str(p2p_port(0)))
self.nodes.append(TestNode(i, cachedir, extra_args=[], rpchost=None, timewait=None, binary=None, stderr=None, mocktime=self.mocktime, coverage_dir=None))
self.nodes[i].args = args
self.nodes[i].start()
# Wait for RPC connections to be ready
for node in self.nodes:
node.wait_for_rpc_connection()
# Create a 200-block-long chain; each of the 4 first nodes
# gets 25 mature blocks and 25 immature.
# Note: To preserve compatibility with older versions of
# initialize_chain, only 4 nodes will generate coins.
#
# blocks are created with timestamps 10 minutes apart
# starting from 2010 minutes in the past
self.enable_mocktime()
block_time = self.mocktime - (201 * 10 * 60)
for i in range(2):
for peer in range(4):
for j in range(25):
set_node_times(self.nodes, block_time)
self.nodes[peer].generate(1)
block_time += 10 * 60
# Must sync before next peer starts generating blocks
sync_blocks(self.nodes)
# Shut them down, and clean up cache directories:
self.stop_nodes()
self.nodes = []
self.disable_mocktime()
for i in range(MAX_NODES):
os.remove(log_filename(cachedir, i, "debug.log"))
os.remove(log_filename(cachedir, i, "db.log"))
os.remove(log_filename(cachedir, i, "peers.dat"))
os.remove(log_filename(cachedir, i, "fee_estimates.dat"))
for i in range(num_nodes):
from_dir = os.path.join(cachedir, "node" + str(i))
to_dir = os.path.join(test_dir, "node" + str(i))
shutil.copytree(from_dir, to_dir)
initialize_datadir(test_dir, i) # Overwrite port/rpcport in bitcoin.conf
def _initialize_chain_clean(self, test_dir, num_nodes):
"""Initialize empty blockchain for use by the test.
Create an empty blockchain and num_nodes wallets.
Useful if a test case wants complete control over initialization."""
for i in range(num_nodes):
initialize_datadir(test_dir, i)
class ComparisonTestFramework(BitcoinTestFramework):
"""Test framework for doing p2p comparison testing
Sets up some bitcoind binaries:
- 1 binary: test binary
- 2 binaries: 1 test binary, 1 ref binary
- n>2 binaries: 1 test binary, n-1 ref binaries"""
def __init__(self):
super().__init__()
self.num_nodes = 2
self.setup_clean_chain = True
def add_options(self, parser):
parser.add_option("--testbinary", dest="testbinary",
default=os.getenv("BITCOIND", "bitcoind"),
help="bitcoind binary to test")
parser.add_option("--refbinary", dest="refbinary",
default=os.getenv("BITCOIND", "bitcoind"),
help="bitcoind binary to use for reference nodes (if any)")
def setup_network(self):
extra_args = [['-whitelist=127.0.0.1']]*self.num_nodes
if hasattr(self, "extra_args"):
extra_args = self.extra_args
self.nodes = self.start_nodes(
self.num_nodes, self.options.tmpdir, extra_args,
binary=[self.options.testbinary] +
[self.options.refbinary] * (self.num_nodes - 1))
class SkipTest(Exception):
"""This exception is raised to skip a test"""
def __init__(self, message):
self.message = message
| 41.389362 | 310 | 0.611114 | [
"MIT"
] | Ilikenumber0/CoinKhongCoGiaTri | test/functional/test_framework/test_framework.py | 19,453 | Python |
from datetime import datetime
from typing import Any, List, Union
import pytest
from neuro_sdk import BlobCommonPrefix, BlobObject, Bucket, BucketEntry
from neuro_cli.formatters.blob_storage import (
BaseBlobFormatter,
LongBlobFormatter,
SimpleBlobFormatter,
)
class TestBlobFormatter:
buckets: List[Bucket] = [
Bucket(
id="bucket-1",
name="neuro-my-bucket",
created_at=datetime(2018, 1, 1, 3),
cluster_name="test-cluster",
owner="test-user",
provider=Bucket.Provider.AWS,
imported=False,
),
Bucket(
id="bucket-2",
name="neuro-public-bucket",
created_at=datetime(2018, 1, 1, 17, 2, 4),
cluster_name="test-cluster",
owner="public",
provider=Bucket.Provider.AWS,
imported=False,
),
Bucket(
id="bucket-3",
name="neuro-shared-bucket",
created_at=datetime(2018, 1, 1, 13, 1, 5),
cluster_name="test-cluster",
owner="another-user",
provider=Bucket.Provider.AWS,
imported=False,
),
]
blobs: List[BucketEntry] = [
BlobObject(
key="file1024.txt",
modified_at=datetime(2018, 1, 1, 14, 0, 0),
bucket=buckets[0],
size=1024,
),
BlobObject(
key="file_bigger.txt",
modified_at=datetime(2018, 1, 1, 14, 0, 0),
bucket=buckets[1],
size=1_024_001,
),
BlobObject(
key="folder2/info.txt",
modified_at=datetime(2018, 1, 1, 14, 0, 0),
bucket=buckets[2],
size=240,
),
BlobObject(
key="folder2/",
modified_at=datetime(2018, 1, 1, 14, 0, 0),
bucket=buckets[2],
size=0,
),
]
folders: List[BucketEntry] = [
BlobCommonPrefix(bucket=buckets[0], key="folder1/", size=0),
BlobCommonPrefix(bucket=buckets[1], key="folder2/", size=0),
]
all: List[Union[Bucket, BucketEntry]] = [*buckets, *blobs, *folders]
@pytest.mark.parametrize(
"formatter",
[
(SimpleBlobFormatter(color=False, uri_formatter=str)),
(LongBlobFormatter(human_readable=False, color=False, uri_formatter=str)),
],
)
def test_long_formatter(self, rich_cmp: Any, formatter: BaseBlobFormatter) -> None:
for index, item in enumerate(self.all):
rich_cmp(formatter(item), index=index)
| 29.011111 | 87 | 0.542704 | [
"Apache-2.0"
] | neuro-inc/platform-client-python | neuro-cli/tests/unit/formatters/test_blob_formatters.py | 2,611 | Python |
from pywebhdfs.webhdfs import PyWebHdfsClient as h
hdfs=h(host='sandbox.hortonworks.com',port='50070',user_name='raj_ops')
ls=hdfs.list_dir('/')
ls['FileStatuses']['FileStatus'][0]
hdfs.make_dir('/samples',permission=755)
f=open('/home/pcrickard/sample.csv')
d=f.read()
hdfs.create_file('/samples/sample.csv',d)
hdfs.read_file('/samples/sample.csv')
hdfs.get_file_dir_status('/samples/sample.csv')
from pyhive import hive
c=hive.connect('sandbox.hortonworks.com').cursor()
c.execute('CREATE TABLE FromPython (age int, name string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ","')
c.execute("LOAD DATA INPATH '/samples/sample.csv' OVERWRITE INTO TABLE FromPython")
c.execute("SELECT * FROM FromPython")
result=c.fetchall()
| 24.193548 | 108 | 0.736 | [
"MIT"
] | PacktPublishing/Mastering-Geospatial-Analysis-with-Python | Chapter16/B07333_16.py | 750 | Python |
# -*- coding: utf-8 -*-
"""
@author: alex
"""
import numpy as np
def main():
"""Main program execution."""
n,h1,h2,h3 = generate_ammonia_sites()
nList = [[1,2,3],[0],[0],[0]]
return [n,h1,h2,h3], nList
def generate_ammonia_sites():
"""Generate the locations for the atoms in the ammonia molecule"""
x,y = np.array([1.,0.,0.]), np.array([0.,1.,0.])
#atomic distance (angstroms)
a = 1.40
n = np.array([0.,0.,0.])
h1 = n + a*y
h2 = n - a*y/2. + a*x*(np.sqrt(3)/2)
h3 = h2 - a*x*np.sqrt(3)
return n,h1,h2,h3
| 17.885714 | 70 | 0.484026 | [
"MIT"
] | ajkerr0/kappa | kappa/lattice/ammonia.py | 626 | Python |
# -*- coding: utf-8 -*-
# an ugly hack to convert some stuff into other stuff...
# EDIT THESE #####################################################################
names_to_highlight = ['Eren AM',
'Delmont TO',
'Esen ÖC',
'Lee STM',
'Shaiber A',
'Kiefl E',
'Cui S',
'Watson AR',
'Lolans K']
journal_name_fixes = [('The ISME journal', 'ISME J'),
('Proceedings of the National Academy of Sciences of the United States of America', 'Proc Natl Acad Sci U S A'),
('Proceedings of the National Academy of Sciences', 'Proc Natl Acad Sci U S A'),
('Frontiers in Microbiology', 'Front Microbiol')]
keep_pubs_after_year = 2009
##################################################################################
import os
import sys
from datetime import datetime
try:
import anvio.utils as u
from anvio.errors import ConfigError
except:
sys.stderr.write("This program requires anvi'o to be installed :/\n")
sys.exit(-1)
class Publications:
def __init__(self, pubs_file_path='pubs.txt', pubs_info_file_path='pubs_info.txt'):
"""Takes an EndNote library exported a TXT file (`pubs_file_path`), and an optional\
TAB-delimited info file path with DOI identifiers (`pubs_info_file_path`), and\
generates some Markdown formatted output.
Here is an info line from the EndNote:
Winterberg, K. M., and Reznikoff, W. S. (2007). "Screening transposon mutant libraries using full-genome oligonucleotide microarrays." Methods Enzymol, 421, 110-25.
Absolute matching to this format is required.
Expected headers in the TAB-delimited pubs info file are 'doi', 'highlights',\
and 'featured_image'.
- doi: The DOI of the pub matching to a pubs file path entry.
- highlights: Brief bullet points about the work. Each pont must be separated\
from the rest with a ';' character. HTML tags are OK.
- featured_image: A URL to an image.
If things are not working, feel free to write to meren at uchicago.edu
"""
self.info = {}
self.pubs_dict = {}
self.journals_list = []
self.authors_list = []
self.recent_authors_list = []
self.author_links = {}
self.pubs_file_path = pubs_file_path
self.pubs_info_file_path = pubs_info_file_path
def get_author_highlights(self, pub):
authors_str = []
for author in pub['authors']:
if author in pub['co_first_authors']:
author_h = author + '<sup>☯</sup>'
elif author in pub['co_senior_authors']:
author_h = author + '<sup>‡</sup>'
else:
author_h = author
if author in names_to_highlight:
authors_str.append('<span class="pub-member-author">%s</span>' % (author_h))
else:
authors_str.append(author_h)
return ', '.join(authors_str)
def parse_pubs_txt(self):
if os.path.exists(self.pubs_info_file_path):
self.info = u.get_TAB_delimited_file_as_dictionary(self.pubs_info_file_path)
pubs_header = u.get_columns_of_TAB_delim_file(self.pubs_file_path, include_first_column=True)
headers_expected = ['Authors', 'Title', 'Publication', 'Volume', 'Number', 'Pages', 'Year', 'doi']
missing_headers = [h for h in pubs_header if h not in headers_expected]
if len(missing_headers):
raise ConfigError("Sorry, the pubs.txt seems to be missing some of the headers that are mandatory. Each of \
the columns in the following list must be present in this file: %s (hint: yours do not have\
the following: %s)." % (', '.join(headers_expected), ', '.join(missing_headers)))
self.pubs_txt = u.get_TAB_delimited_file_as_dictionary(self.pubs_file_path, indexing_field=pubs_header.index('doi'))
for doi in self.pubs_txt:
authors = []
co_first_authors = []
co_senior_authors = []
p = self.pubs_txt[doi]
for author in [_.strip() for _ in p['Authors'].split(';')]:
if not len(author):
continue
author_last_name, author_first_name_raw = [_.strip() for _ in author.split(',')]
author_first_name = ''.join([n[0] for n in author_first_name_raw.split()])
author_final_name = '%s %s' % (author_last_name, author_first_name)
if author_first_name_raw.endswith('*'):
co_first_authors.append(author_final_name)
elif author_first_name_raw.endswith('+'):
co_senior_authors.append(author_final_name)
authors.append(author_final_name)
if p['Number']:
issue = '%s(%s):%s' % (p['Volume'], p['Number'], p['Pages'])
else:
issue = '%s:%s' % (p['Volume'], p['Pages'])
year = p['Year'].strip()
pub_entry = {'authors': authors, 'title': p['Title'], 'journal': p['Publication'], 'issue': issue, 'doi': doi, 'year': year, 'co_first_authors': co_first_authors, 'co_senior_authors': co_senior_authors}
if year not in self.pubs_dict:
self.pubs_dict[year] = [pub_entry]
else:
self.pubs_dict[year].append(pub_entry)
def get_markdown_text_for_pub(self, pub):
"""Gets a dictionary `pub`, returns a markdown formatted text.
An example pub:
{'authors': 'McLellan, S. L., and Eren, A. M.',
'doi': '10.1016/j.tim.2014.08.002',
'issue': '22(12), 697-706',
'title': 'Discovering new indicators of fecal pollution.',
'journal': 'Trends Microbiol',
'year': 2014}
"""
pub_md = []
A = lambda s: pub_md.append(s)
A('<div class="pub">')
A('''<div class='altmetric-embed' data-badge-type='donut' data-doi="%s"></div>''' % pub['doi'])
A('''<div class="__dimensions_badge_embed__" data-doi="%s" data-hide-zero-citations="true" data-legend="hover-bottom" data-style="small_circle"></div>''' % pub['doi'])
if pub['doi']:
A(' <h3><a href="%s" target="_new">%s</a></h3>' % (' https://doi.org/%s' % (pub['doi']), pub['title']))
else:
A(' <h3><a href="http://scholar.google.com/scholar?hl=en&q=%s" target="_new">%s</a></h3>' % ('http://scholar.google.com/scholar?hl=en&q=%s' % (pub['title'].replace(' ', '+')), pub['title']))
A(' <span class="pub-authors">%s</span>' % self.get_author_highlights(pub))
if pub['co_first_authors'] and not pub['co_senior_authors']:
A(' <span class="pub-co-first-authors"><sup>☯</sup>Co-first authors</span>')
elif pub['co_first_authors'] and pub['co_senior_authors']:
A(' <span class="pub-co-first-authors"><sup>☯</sup>Co-first authors; <sup>‡</sup>Co-senior authors</span>')
elif pub['co_senior_authors'] and not pub['co_first_authors']:
A(' <span class="pub-co-first-authors"><sup>‡</sup>Co-senior authors</span>')
if pub['doi'] in self.info:
info = self.info[pub['doi']]
A(' <div class="%s">' % ('pub-info' if info['featured_image'] else 'pub-info-no-image'))
if info['featured_image']:
A(' <div class="pub-featured-image">')
A(' <a href="%s"><img src="%s" style="max-width: 100px; max-height: 80px; width: auto; border: none; height: auto; margin: 0 auto; display: block; transform: translateY(15%%);"/></a>' % (info['featured_image'], info['featured_image']))
A(' </div>')
highlights = info['highlights'].split(';') if info['highlights'] else None
if highlights:
A(' <div class="%s">' % ('pub-highlights' if info['featured_image'] else 'pub-highlights-no-image'))
A(' %s' % '<br>'.join(['<span style="display: inline-block; padding-bottom: 5px;">- %s</span>' % h for h in highlights]))
A(' </div>')
A(' </div>')
A(' <span class="pub-journal"><b>%s</b>, %s.</span>' % (pub['journal'], pub['issue']))
A('</div>\n')
return '\n'.join(pub_md)
def store_markdown_output_for_pubs(self, output_file_path):
# years = ''.join(['<a href="#%s"><span class="category-item">%s <small>(%d)</small></span></a>' % (y, y, len(self.pubs_dict[y])) for y in sorted(list(self.pubs_dict.keys()), reverse=True)])
years = ''.join(['<a href="#%s"><span class="category-item">%s</span></a>' % (y, y) for y in sorted(list(self.pubs_dict.keys()), reverse=True)])
output_file = open(output_file_path, 'w')
W = lambda s: output_file.write(s + '\n')
W('---')
W('layout: publications')
W('modified: %s' % datetime.today().strftime('%Y-%m-%d'))
W('comments: false')
W('---\n')
W('''<script type='text/javascript' src='https://d1bxh8uas1mnw7.cloudfront.net/assets/embed.js'></script>\n''')
W('''<script async src="https://badge.dimensions.ai/badge.js" charset="utf-8"></script>\n''')
W('<div class="category-box">\n%s\n</div>\n' % years)
W('{:.notice}\n')
W("This page shows publications that are most reflective of our interests. For a complete list, please see <a href='https://scholar.google.com/citations?user=GtLLuxoAAAAJ&view_op=list_works&sortby=pubdate' target='_blank'>Meren's Google Scholar page</a>.\n")
for year in sorted(list(self.pubs_dict.keys()), reverse=True):
W('<a name="%s"> </a>' % year)
W('<h1>%s</h1>\n' % year)
for pub in self.pubs_dict[year]:
W(self.get_markdown_text_for_pub(pub))
W('')
if __name__ == '__main__':
pubs = Publications()
try:
pubs.parse_pubs_txt()
pubs.store_markdown_output_for_pubs('publications/index.md')
except ConfigError as e:
print(e)
sys.exit(-1)
| 44.776824 | 266 | 0.557749 | [
"MIT"
] | Ibrahimmohamed33/web | pubs.py | 10,446 | Python |
# MIT License
# Copyright (c) 2020 Andrew Wells
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
print_LTL_game = True
obstacle_cells = [[3,0], [3,1], [3,3], [3,4], [3,5], [3,6], [3,7], [3,8], [5,2], [5,3], [5,4], [5,5], [5,6], [5,7], [5,8], [5,9], [7,0], [7,1], [7,3], [7,4], [7,5], [7,6], [7,7], [7,8]]
num_rows = 10
num_cols = 10
probN = 0.69
probE = 0.1
probW = 0.1
probB = 0.01
probS = 0.1
def rc2i_short(row, col):
if row < num_rows and row >= 0 and col < num_cols and col >= 0:
return row * num_rows + col
return -1
def rc2i(row, col):
cell = -1
if row < num_rows and row >= 0 and col < num_cols and col >= 0:
cell = row * num_rows + col
for c in obstacle_cells:
if cell == rc2i_short(c[0], c[1]):
return -1
return cell
def printNorth(row, col):
extraProb = 0
str = "[] x={} -> ".format(rc2i(i,j))
if(rc2i(i-1, j) == -1):
extraProb += probN
else:
str = str + " {}:(x'={}) +".format(probN, rc2i(i-1, j))
if(rc2i(i+1, j) == -1):
extraProb = extraProb + probB
else:
str = str + " {}:(x'={}) +".format(probB, rc2i(i+1, j))
if(rc2i(i, j+1) == -1):
extraProb = extraProb + probE
else:
str = str + " {}:(x'={}) +".format(probE, rc2i(i, j+1))
if(rc2i(i, j-1) == -1):
extraProb = extraProb + probW
else:
str = str + " {}:(x'={}) +".format(probW, rc2i(i, j-1))
print(str + " {}:(x'={});".format(probS+extraProb, rc2i(i,j)))
def printSouth(row, col):
extraProb = 0
str = "[] x={} -> ".format(rc2i(i,j))
if(rc2i(i-1, j) == -1):
extraProb += probB
else:
str = str + " {}:(x'={}) +".format(probB, rc2i(i-1, j))
if(rc2i(i+1, j) == -1):
extraProb = extraProb + probN
else:
str = str + " {}:(x'={}) +".format(probN, rc2i(i+1, j))
if(rc2i(i, j+1) == -1):
extraProb = extraProb + probW
else:
str = str + " {}:(x'={}) +".format(probW, rc2i(i, j+1))
if(rc2i(i, j-1) == -1):
extraProb = extraProb + probE
else:
str = str + " {}:(x'={}) +".format(probE, rc2i(i, j-1))
print(str + " {}:(x'={});".format(probS+extraProb, rc2i(i,j)))
def printEast(row, col):
extraProb = 0
str = "[] x={} -> ".format(rc2i(i,j))
if(rc2i(i-1, j) == -1):
extraProb += probW
else:
str = str + " {}:(x'={}) +".format(probW, rc2i(i-1, j))
if(rc2i(i+1, j) == -1):
extraProb = extraProb + probE
else:
str = str + " {}:(x'={}) +".format(probE, rc2i(i+1, j))
if(rc2i(i, j+1) == -1):
extraProb = extraProb + probN
else:
str = str + " {}:(x'={}) +".format(probN, rc2i(i, j+1))
if(rc2i(i, j-1) == -1):
extraProb = extraProb + probB
else:
str = str + " {}:(x'={}) +".format(probB, rc2i(i, j-1))
print(str + " {}:(x'={});".format(probS+extraProb, rc2i(i,j)))
def printWest(row, col):
extraProb = 0
str = "[] x={} -> ".format(rc2i(i,j))
if(rc2i(i-1, j) == -1):
extraProb += probE
else:
str = str + " {}:(x'={}) +".format(probE, rc2i(i-1, j))
if(rc2i(i+1, j) == -1):
extraProb = extraProb + probW
else:
str = str + " {}:(x'={}) +".format(probW, rc2i(i+1, j))
if(rc2i(i, j+1) == -1):
extraProb = extraProb + probB
else:
str = str + " {}:(x'={}) +".format(probB, rc2i(i, j+1))
if(rc2i(i, j-1) == -1):
extraProb = extraProb + probN
else:
str = str + " {}:(x'={}) +".format(probN, rc2i(i, j-1))
print(str + " {}:(x'={});".format(probS+extraProb, rc2i(i,j)))
print("mdp")
print("")
print("module M1")
print("")
if print_LTL_game:
print(" x : [0..{}] init 0;".format(num_rows*num_cols))
else:
print(" x : [0..{}] init 0;".format(num_rows*num_cols-1))
#print inner cells
for i in range (num_rows):
for j in range (num_cols):
##Moving north
printNorth(i,j)
printSouth(i,j)
printEast(i,j)
printWest(i,j)
if print_LTL_game:
print("")
for i in range (num_rows*num_cols):
print("[] x={} -> 1:(x'={});".format(i, num_rows*num_cols))
print("[] x={} -> 1:(x'={});".format(num_rows*num_cols, num_rows*num_cols))
print("")
print("endmodule")
print("")
print("// labels")
print("label \"initial\" = (x=0);")
print("label \"loca\" = (x=26);")
print("label \"locb\" = (x=85);")
print("label \"locc\" = (x=16);")
print("label \"locd\" = (x=7);")
print("label \"loce\" = (x=45);")
print("label \"locf\" = (x=91);")
print("label \"locg\" = (x=41);")
print("label \"loch\" = (x=67);")
print("label \"loci\" = (x=20);")
print("label \"zbad\" = (x=2);")
print("label \"done\" = (x={});".format(num_rows*num_cols)) | 32.647727 | 185 | 0.540724 | [
"MIT"
] | andrewmw94/gandalf_2020_experiments | gridworld_hallways/make_grid_mdp.py | 5,746 | Python |
# pylint: disable=redefined-outer-name
from .utils import TestCase
from .utils import run_tests_assert_success
import itertools
import os
import slash
import pytest
from .utils.suite_writer import Suite
@pytest.mark.parametrize('parametrize', [True, False])
def test_class_name(suite, suite_test, test_type, parametrize):
if parametrize:
suite_test.add_parameter(num_values=3)
summary = suite.run()
for result in summary.get_all_results_for_test(suite_test):
if test_type == 'method':
assert result.test_metadata.class_name.startswith('Test')
assert '(' not in result.test_metadata.class_name
elif test_type == 'function':
assert result.test_metadata.class_name is None
else:
raise NotImplementedError() # pragma: no cover
@pytest.mark.parametrize('parametrize', [True, False])
def test_function_name(suite, suite_test, parametrize):
if parametrize:
suite_test.add_parameter(num_values=3)
summary = suite.run()
for result in summary.get_all_results_for_test(suite_test):
function_name = result.test_metadata.function_name
assert function_name.startswith('test_')
assert '.' not in result.test_metadata.function_name
assert '(' not in result.test_metadata.function_name
def test_variation(suite, suite_test):
fixture = suite.slashconf.add_fixture()
param = fixture.add_parameter() # pylint: disable=unused-variable
suite_test.depend_on_fixture(fixture)
suite_test.append_line('slash.context.result.data["variation"] = slash.context.test.__slash__.variation.values.copy()')
summary = suite.run()
for result in summary.get_all_results_for_test(suite_test):
assert len(result.data['variation']) == 1
assert fixture.name not in result.data['variation']
assert '{}.{}'.format(fixture.name, param.name) in result.data['variation']
def test_function_name_with_special_parameters(test_type):
suite = Suite()
assert len(suite) == 0 # pylint: disable=len-as-condition
suite_test = suite.add_test(type=test_type)
values = ['a.b', 'a(b']
suite_test.add_parameter(values=values)
# we can't verify result because we would not be able to parse the function properly
# TODO: this will change once we properly support variations metadata # pylint: disable=fixme
summary = suite.run(verify=False, sort=False)
for result, value in itertools.zip_longest(summary.session.results, values):
function_name = result.test_metadata.function_name
assert value not in function_name
assert '.' not in result.test_metadata.function_name
assert '(' not in result.test_metadata.function_name
assert function_name.startswith('test_')
def test_module_name_not_none_or_empty_string(suite):
for result in suite.run().session.results:
assert result.test_metadata.module_name
def test_test_index(suite):
index = None
session = suite.run().session
for index, result in enumerate(session.results):
assert result.test_metadata.test_index0 == index
assert result.test_metadata.test_index1 == index + 1
assert index > 0
def test_set_test_name(test_metadata):
assert test_metadata.file_path in str(test_metadata)
custom_name = 'some_custom_name'
test_metadata.set_test_full_name(custom_name)
assert str(test_metadata) == '<{}>'.format(custom_name)
def test_class_name_with_dot_parameters():
# pylint: disable=unused-argument
@slash.parametrize('path', ['x.y'])
def test_something(path):
pass
with slash.Session() as s: # pylint: disable=unused-variable
loader = slash.loader.Loader()
[test] = loader.get_runnables(test_something) # pylint: disable=unbalanced-tuple-unpacking
assert test.__slash__.class_name is None
def test_set_file_path(test_metadata):
file_path = '/tmp/file_path.py'
assert file_path not in test_metadata.address
test_metadata.set_file_path(file_path)
assert test_metadata.file_path == file_path
assert file_path in test_metadata.address
def test_mark_interactive(test_metadata):
test_metadata.mark_interactive()
assert test_metadata.is_interactive()
@pytest.fixture
def test_metadata(suite, suite_test):
return suite.run()[suite_test].test_metadata
class TestMetadataTest(TestCase):
loaded_tests = []
def setUp(self):
@slash.hooks.register
def tests_loaded(tests): # pylint: disable=unused-variable
TestMetadataTest.loaded_tests = tests
super(TestMetadataTest, self).setUp()
self.root = self.get_new_path()
self.filename = os.path.join(self.root, "testfile.py")
with open(self.filename, "w") as f:
f.write(_TEST_FILE_TEMPLATE)
with slash.Session() as s:
self.session = run_tests_assert_success(self.filename, session=s)
self.tests = self.loaded_tests
self.results = list(self.session.results.iter_test_results())
self.results.sort(key=lambda result: str(result.test_metadata))
def test_tests_have_correct_metadata(self):
for test, result in zip(self.tests, self.session.results.iter_test_results()):
self.assertIs(test.__slash__, result.test_metadata)
def test_simple_test_address(self):
self.assertEqual(self.results[0].test_metadata.address, "{}:T001.test_method".format(self.filename))
def test_parameterized_test_address(self):
parameterized = set(x.test_metadata.address for x in self.results[1:])
self.assertEqual(parameterized, set(
"{0}:T002.test_parameters(after:c={2},b={3},before:a={1})".format(self.filename, a, c, b)
for a, b, c in itertools.product([1, 2], [3, 4], [5, 6])))
_TEST_FILE_TEMPLATE = """
import slash
class T001(slash.Test):
def test_method(self):
pass
class T002(slash.Test):
@slash.parameters.iterate(a=[1, 2])
def before(self, a):
pass
@slash.parameters.iterate(b=[3, 4])
def test_parameters(self, b):
pass
@slash.parameters.iterate(c=[5, 6])
def after(self, c):
pass
"""
| 34.842697 | 123 | 0.704611 | [
"BSD-3-Clause"
] | bheesham/slash | tests/test_test_metadata.py | 6,202 | Python |
# Time: O(n)
# Space: O(1)
#
# You are climbing a stair case. It takes n steps to reach to the top.
#
# Each time you can either climb 1 or 2 steps.
# In how many distinct ways can you climb to the top?
class Solution:
"""
:type n: int
:rtype: int
"""
def climbStairs(self, n):
prev, current = 0, 1
for i in xrange(n):
prev, current = current, prev + current,
return current
def climbStairs1(self, n):
if n == 1:
return 1
if n == 2:
return 2
return self.climbStairs(n - 1) + self.climbStairs(n - 2)
if __name__ == "__main__":
result = Solution().climbStairs(2)
print result
| 22.516129 | 70 | 0.561605 | [
"MIT"
] | LimberenceCheng/LeetCode | Python/climbing-stairs.py | 698 | Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
###############################################################################
# $Id$
#
# Project: GDAL/OGR Test Suite
# Purpose: Style testing.
# Author: Even Rouault <even dot rouault at mines dash paris dot org>
#
###############################################################################
# Copyright (c) 2014, Even Rouault <even dot rouault at mines-paris dot org>
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
###############################################################################
import sys
sys.path.append( '../pymod' )
import gdaltest
from osgeo import ogr
from osgeo import gdal
###############################################################################
#
#
def ogr_style_styletable():
style_table = ogr.StyleTable()
style_table.AddStyle("style1_normal", 'SYMBOL(id:"http://style1_normal",c:#67452301)')
gdal.PushErrorHandler('CPLQuietErrorHandler')
ret = style_table.SaveStyleTable('/nonexistingdir/nonexistingfile')
gdal.PopErrorHandler()
if ret != 0:
gdaltest.post_reason('failure')
print(ret)
return 'fail'
if style_table.SaveStyleTable("/vsimem/out.txt") != 1:
gdaltest.post_reason('failure')
return 'fail'
style_table = None
style_table = ogr.StyleTable()
gdal.PushErrorHandler('CPLQuietErrorHandler')
ret = style_table.LoadStyleTable('/nonexisting')
gdal.PopErrorHandler()
if ret != 0:
gdaltest.post_reason('failure')
return 'fail'
if style_table.LoadStyleTable('/vsimem/out.txt') != 1:
gdaltest.post_reason('failure')
return 'fail'
gdal.Unlink('/vsimem/out.txt')
gdal.PushErrorHandler('CPLQuietErrorHandler')
ret = style_table.Find("non_existing_style")
gdal.PopErrorHandler()
if ret is not None:
gdaltest.post_reason('failure')
return 'fail'
if style_table.Find("style1_normal") != 'SYMBOL(id:"http://style1_normal",c:#67452301)':
gdaltest.post_reason('failure')
return 'fail'
style = style_table.GetNextStyle()
if style != 'SYMBOL(id:"http://style1_normal",c:#67452301)':
gdaltest.post_reason('failure')
return 'fail'
style_name = style_table.GetLastStyleName()
if style_name != 'style1_normal':
gdaltest.post_reason('failure')
return 'fail'
style = style_table.GetNextStyle()
if style is not None:
gdaltest.post_reason('failure')
return 'fail'
style_table.ResetStyleStringReading()
style = style_table.GetNextStyle()
if style is None:
gdaltest.post_reason('failure')
return 'fail'
# GetStyleTable()/SetStyleTable() on data source
ds = ogr.GetDriverByName('Memory').CreateDataSource('')
if ds.GetStyleTable() is not None:
gdaltest.post_reason('failure')
return 'fail'
ds.SetStyleTable(None)
if ds.GetStyleTable() is not None:
gdaltest.post_reason('failure')
return 'fail'
ds.SetStyleTable(style_table)
style_table2 = ds.GetStyleTable()
style = style_table2.GetNextStyle()
if style != 'SYMBOL(id:"http://style1_normal",c:#67452301)':
gdaltest.post_reason('failure')
return 'fail'
# GetStyleTable()/SetStyleTable() on layer
lyr = ds.CreateLayer('foo')
if lyr.GetStyleTable() is not None:
gdaltest.post_reason('failure')
return 'fail'
lyr.SetStyleTable(None)
if lyr.GetStyleTable() is not None:
gdaltest.post_reason('failure')
return 'fail'
lyr.SetStyleTable(style_table)
style_table2 = lyr.GetStyleTable()
style = style_table2.GetNextStyle()
if style != 'SYMBOL(id:"http://style1_normal",c:#67452301)':
gdaltest.post_reason('failure')
return 'fail'
ds = None
return 'success'
###############################################################################
# Build tests runner
gdaltest_list = [
ogr_style_styletable ]
if __name__ == '__main__':
gdaltest.setup_run( 'ogr_style' )
gdaltest.run_tests( gdaltest_list )
gdaltest.summarize()
| 33.575163 | 92 | 0.633444 | [
"MIT"
] | riseofthetigers/GDAL | autotest/ogr/ogr_style.py | 5,137 | Python |
import os.path
import time
from resource_management.core.exceptions import Fail
from resource_management.core.source import Template
from resource_management.core.source import StaticFile
from resource_management.core.source import DownloadSource
from resource_management.core.resources import Execute
from resource_management.core.resources.system import Directory
from resource_management.core.resources.system import File
from resource_management.libraries.functions import get_user_call_output
from resource_management.libraries.functions import format
from resource_management.libraries.functions.show_logs import show_logs
from resource_management.libraries.functions.security_commons import update_credential_provider_path
from resource_management.libraries.resources.xml_config import XmlConfig
from resource_management.core.logger import Logger
from resource_management.libraries.script.config_dictionary import UnknownConfiguration
import beacon_utils
from resource_management.libraries.script import Script
import ranger_api_functions
def install_beacon():
import params
Directory([params.etc_prefix_dir],
owner=params.beacon_user,
group=params.user_group,
mode=0755,
create_parents=True)
if not os.path.exists(Script.get_stack_root() + '/' + params.version_dir) or not os.path.exists(
params.install_dir):
Execute('rm -rf %s' % Script.get_stack_root() + '/' + params.version_dir)
Execute('rm -rf %s' % params.install_dir)
Execute(
'wget ' + params.download_url + ' -O /tmp/' + params.filename,
user=params.beacon_user)
Execute('tar -zxf /tmp/' + params.filename + ' -C ' + Script.get_stack_root())
Execute('ln -s ' + Script.get_stack_root() + '/' + params.version_dir + ' ' + params.install_dir)
Execute(' cp -r ' + params.install_dir + '/conf/* ' + params.etc_prefix_dir)
Execute(' rm -rf ' + params.install_dir + '/conf')
Execute('ln -s ' + params.etc_prefix_dir + ' ' + params.install_dir +
'/conf')
Execute('chown -R %s:%s %s/%s' %
(params.beacon_user, params.user_group, params.stack_root, params.version_dir))
Execute('chown -R %s:%s %s' % (params.beacon_user, params.user_group,
params.install_dir))
Execute('/bin/rm -f /tmp/' + params.filename)
def beacon(type, action=None, upgrade_type=None):
import params
if action == 'config':
create_directory(params.beacon_home_dir)
create_directory(params.beacon_plugin_staging_dir)
cloud_cred_provider = params.beacon_cloud_cred_provider_dir.split('://')[1]
cloud_cred_parts = cloud_cred_provider.split('/', 1)
create_directory("/" + cloud_cred_parts[1], cloud_cred_parts[0])
if params.is_hive_installed:
if not isinstance(params.hive_repl_cmrootdir, UnknownConfiguration):
beacon_utils.create_hdfs_directory(params.hive_repl_cmrootdir,
params.hive_user,
01777)
if not isinstance(params.hive_repl_rootdir, UnknownConfiguration):
beacon_utils.create_hdfs_directory(params.hive_repl_rootdir,
params.hive_user,
0700)
Directory(params.beacon_pid_dir,
owner=params.beacon_user,
create_parents=True,
mode=0755,
cd_access="a",
)
Directory(params.beacon_data_dir,
owner=params.beacon_user,
create_parents=True,
mode=0755,
cd_access="a",
)
Directory(params.beacon_log_dir,
owner=params.beacon_user,
create_parents=True,
mode=0755,
cd_access="a",
)
Directory(params.beacon_webapp_dir,
owner=params.beacon_user,
create_parents=True)
Directory(params.beacon_home,
owner=params.beacon_user,
create_parents=True)
Directory(params.etc_prefix_dir,
mode=0755,
create_parents=True)
Directory(params.beacon_conf_dir,
owner=params.beacon_user,
create_parents=True)
environment_dictionary = {
"HADOOP_HOME": params.hadoop_home_dir,
"JAVA_HOME": params.java_home,
"BEACON_LOG_DIR": params.beacon_log_dir,
"BEACON_PID_DIR": params.beacon_pid_dir,
"BEACON_DATA_DIR": params.beacon_data_dir,
"BEACON_CLUSTER": params.beacon_cluster_name,
"HADOOP_CONF": params.hadoop_conf_dir
}
pid = get_user_call_output.get_user_call_output(format("cat {server_pid_file}"), user=params.beacon_user,
is_checked_call=False)[1]
process_exists = format("ls {server_pid_file} && ps -p {pid}")
if type == 'server':
if action == 'start':
try:
if params.credential_store_enabled:
if 'hadoop.security.credential.provider.path' in params.beacon_env:
credential_provider_path = params.beacon_env['hadoop.security.credential.provider.path']
credential_provider_src_path = credential_provider_path[len('jceks://file'):]
File(params.beacon_credential_provider_path[len('jceks://file'):],
owner=params.beacon_user,
group=params.user_group,
mode=0640,
content=StaticFile(credential_provider_src_path)
)
else:
Logger.error(
"hadoop.security.credential.provider.path property not found in beacon-env config-type")
File(os.path.join(params.beacon_conf_dir, 'beacon.yml'),
owner='root',
group='root',
mode=0644,
content=Template("beacon.yml.j2")
)
params.beacon_security_site = update_credential_provider_path(
params.beacon_security_site,
'beacon-security-site',
os.path.join(params.beacon_conf_dir, 'beacon-security-site.jceks'),
params.beacon_user,
params.user_group
)
XmlConfig("beacon-security-site.xml",
conf_dir=params.beacon_conf_dir,
configurations=params.beacon_security_site,
configuration_attributes=params.config['configuration_attributes']['beacon-security-site'],
owner=params.beacon_user,
group=params.user_group,
mode=0644
)
Execute(format('{beacon_home}/bin/beacon setup'),
user=params.beacon_user,
path=params.hadoop_bin_dir,
environment=environment_dictionary
)
if params.download_mysql_driver:
download_mysql_driver()
Execute(format('{beacon_home}/bin/beacon start'),
user=params.beacon_user,
path=params.hadoop_bin_dir,
environment=environment_dictionary,
not_if=process_exists,
)
if params.has_ranger_admin:
ranger_admin_url = params.config['configurations']['admin-properties']['policymgr_external_url']
ranger_admin_user = params.config['configurations']['ranger-env']['admin_username']
ranger_admin_passwd = params.config['configurations']['ranger-env']['admin_password']
if not params.security_enabled:
# Creating/Updating beacon.ranger.user with role "ROLE_SYS_ADMIN"
response_user = ranger_api_functions.get_user(ranger_admin_url, params.beacon_ranger_user,
format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
if response_user is not None and response_user['name'] == params.beacon_ranger_user:
response_user_role = response_user['userRoleList'][0]
Logger.info(format(
"Beacon Ranger User with username {beacon_ranger_user} exists with role {response_user_role}"))
if response_user_role != "ROLE_SYS_ADMIN":
response_user_role = ranger_api_functions.update_user_role(ranger_admin_url,
params.beacon_ranger_user,
"ROLE_SYS_ADMIN", format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
else:
response_code = ranger_api_functions.create_user(ranger_admin_url,
params.beacon_ranger_user,
params.beacon_ranger_password,
"ROLE_SYS_ADMIN", format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
# Updating beacon_user role depending upon cluster environment
count = 0
while count < 10:
beacon_user_get = ranger_api_functions.get_user(ranger_admin_url, params.beacon_user, format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
if beacon_user_get is not None:
break
else:
time.sleep(10) # delay for 10 seconds
count = count + 1
Logger.error(
format('Retrying to fetch {beacon_user} user from Ranger Admin for {count} time(s)'))
if beacon_user_get is not None and beacon_user_get['name'] == params.beacon_user:
beacon_user_get_role = beacon_user_get['userRoleList'][0]
if params.security_enabled and beacon_user_get_role != "ROLE_SYS_ADMIN":
beacon_service_user = ranger_api_functions.update_user_role(ranger_admin_url,
params.beacon_user,
"ROLE_SYS_ADMIN", format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
elif not params.security_enabled and beacon_user_get_role != "ROLE_USER":
beacon_service_user = ranger_api_functions.update_user_role(ranger_admin_url,
params.beacon_user, "ROLE_USER",
format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
if params.ranger_hive_plugin_enabled:
# Get Ranger Hive default policy for resource database, table, column
response_policy = ranger_api_functions.get_ranger_service_default_policy(ranger_admin_url,
params.service_name,
format(
"{ranger_admin_user}:{ranger_admin_passwd}"),
['database', 'table',
'column'])
if response_policy:
user_present = ranger_api_functions.check_user_policy(response_policy, params.beacon_user)
if not user_present and beacon_user_get is not None and beacon_user_get[
'name'] == params.beacon_user:
policy_id = response_policy['id']
beacon_user_policy_item = {'groups': [], 'conditions': [],
'users': [params.beacon_user],
'accesses': [{'isAllowed': True, 'type': 'all'},
{'isAllowed': True, 'type': 'repladmin'}],
'delegateAdmin': False}
policy_data = ranger_api_functions.update_policy_item(response_policy,
beacon_user_policy_item)
update_policy_response = ranger_api_functions.update_policy(ranger_admin_url, policy_id,
policy_data, format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
# Get Ranger Hive default policy for resource hiveservice
response_policy = ranger_api_functions.get_ranger_service_default_policy(ranger_admin_url,
params.service_name,
format(
"{ranger_admin_user}:{ranger_admin_passwd}"),
['hiveservice'])
if response_policy:
user_present = ranger_api_functions.check_user_policy(response_policy, params.beacon_user)
if not user_present and beacon_user_get is not None and beacon_user_get[
'name'] == params.beacon_user:
# Updating beacon_user in Ranger Hive default policy for resource hiveservice
policy_id = response_policy['id']
beacon_user_policy_item = {'groups': [], 'conditions': [],
'users': [params.beacon_user],
'accesses': [{'isAllowed': True, 'type': 'serviceadmin'}],
'delegateAdmin': False}
policy_data = ranger_api_functions.update_policy_item(response_policy,
beacon_user_policy_item)
update_policy_response = ranger_api_functions.update_policy(ranger_admin_url, policy_id,
policy_data, format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
if params.ranger_atlas_plugin_enabled:
# Creating beacon.atlas.user with role "ROLE_USER"
beacon_atlas_user_response = ranger_api_functions.get_user(ranger_admin_url,
params.beacon_atlas_user, format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
if beacon_atlas_user_response is not None and beacon_atlas_user_response[
'name'] == params.beacon_atlas_user:
beacon_atlas_user_role = beacon_atlas_user_response['userRoleList'][0]
Logger.info(format(
"Beacon Atlas User with username {beacon_atlas_user} exists with role {beacon_atlas_user_role}"))
else:
beacon_atlas_user_create_response_code = ranger_api_functions.create_user(ranger_admin_url,
params.beacon_atlas_user,
params.beacon_atlas_password,
"ROLE_USER",
format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
if params.security_enabled:
get_beacon_atlas_user = params.beacon_user
else:
get_beacon_atlas_user = params.beacon_atlas_user
if params.is_stack_3_0_or_further:
# Get Ranger Atlas default policy for ENTITY TYPE, ENTITY CLASSIFICATION and ENTITY ID resource
atlas_entity_policy_response = ranger_api_functions.get_ranger_service_default_policy(
ranger_admin_url, params.ranger_atlas_service_name,
format("{ranger_admin_user}:{ranger_admin_passwd}"),
['entity', 'entity-classification', 'entity-type'])
if atlas_entity_policy_response:
beacon_atlas_user_present = ranger_api_functions.check_user_policy(
atlas_entity_policy_response, get_beacon_atlas_user)
if not beacon_atlas_user_present:
# Updating beacon atlas user in Ranger Atlas default policy for entity resource
atlas_entity_policy_id = atlas_entity_policy_response['id']
beacon_atlas_user_policy_item = {'groups': [], 'conditions': [],
'users': [get_beacon_atlas_user], 'accesses': [
{'type': 'entity-read', 'isAllowed': True},
{'type': 'entity-create', 'isAllowed': True},
{'type': 'entity-update', 'isAllowed': True}]}
atlas_entity_policy_data = ranger_api_functions.update_policy_item(
atlas_entity_policy_response, beacon_atlas_user_policy_item)
atlas_update_entity_policy_response = ranger_api_functions.update_policy(
ranger_admin_url, atlas_entity_policy_id, atlas_entity_policy_data,
format("{ranger_admin_user}:{ranger_admin_passwd}"))
# Get Ranger Atlas default policy for ATLAS SERVICE resource
atlas_service_policy_response = ranger_api_functions.get_ranger_service_default_policy(
ranger_admin_url, params.ranger_atlas_service_name,
format("{ranger_admin_user}:{ranger_admin_passwd}"), ['atlas-service'])
if atlas_service_policy_response:
beacon_atlas_user_present = ranger_api_functions.check_user_policy(
atlas_service_policy_response, get_beacon_atlas_user)
if not beacon_atlas_user_present:
# Updating beacon atlas user in Ranger Atlas default policy for service resource
atlas_service_policy_id = atlas_service_policy_response['id']
beacon_atlas_user_policy_item = {'groups': [], 'conditions': [],
'users': [get_beacon_atlas_user], 'accesses': [
{'type': 'admin-export', 'isAllowed': True},
{'type': 'admin-import', 'isAllowed': True}]}
atlas_service_policy_data = ranger_api_functions.update_policy_item(
atlas_service_policy_response, beacon_atlas_user_policy_item)
atlas_service_policy_update_response = ranger_api_functions.update_policy(
ranger_admin_url, atlas_service_policy_id, atlas_service_policy_data,
format("{ranger_admin_user}:{ranger_admin_passwd}"))
# Get Ranger Atlas default policy for TYPE CATEGORY and TYPE resource
atlas_type_category_policy_response = ranger_api_functions.get_ranger_service_default_policy(
ranger_admin_url, params.ranger_atlas_service_name,
format("{ranger_admin_user}:{ranger_admin_passwd}"), ['type', 'type-category'])
if atlas_type_category_policy_response:
beacon_atlas_user_present = ranger_api_functions.check_user_policy(
atlas_type_category_policy_response, get_beacon_atlas_user)
if not beacon_atlas_user_present:
# Updating beacon atlas user in Ranger Atlas default policy for type category and type resource
atlas_type_category_policy_id = atlas_type_category_policy_response['id']
beacon_atlas_user_policy_item = {'groups': [], 'conditions': [],
'users': [get_beacon_atlas_user], 'accesses': [
{'type': 'type-create', 'isAllowed': True},
{'type': 'type-update', 'isAllowed': True},
{'type': 'type-delete', 'isAllowed': True}]}
atlas_type_category_policy_data = ranger_api_functions.update_policy_item(
atlas_type_category_policy_response, beacon_atlas_user_policy_item)
atlas_update_type_category_policy_response = ranger_api_functions.update_policy(
ranger_admin_url, atlas_type_category_policy_id,
atlas_type_category_policy_data,
format("{ranger_admin_user}:{ranger_admin_passwd}"))
else:
# Get Ranger Atlas default policy for ENTITY resource
atlas_policy_response = ranger_api_functions.get_ranger_service_default_policy(
ranger_admin_url, params.ranger_atlas_service_name,
format("{ranger_admin_user}:{ranger_admin_passwd}"), ['entity'])
if atlas_policy_response:
beacon_atlas_user_present = ranger_api_functions.check_user_policy(
atlas_policy_response, get_beacon_atlas_user)
if not beacon_atlas_user_present:
# Updating beacon atlas user in Ranger Atlas default policy for entity resource
atlas_policy_id = atlas_policy_response['id']
beacon_atlas_user_policy_item = {'groups': [], 'conditions': [],
'users': [get_beacon_atlas_user],
'accesses': [{'type': 'read', 'isAllowed': True},
{'type': 'create', 'isAllowed': True},
{'type': 'update', 'isAllowed': True},
{'type': 'delete', 'isAllowed': True},
{'type': 'all', 'isAllowed': True}]}
atlas_policy_data = ranger_api_functions.update_policy_item(atlas_policy_response,
beacon_atlas_user_policy_item)
atlas_update_policy_response = ranger_api_functions.update_policy(ranger_admin_url,
atlas_policy_id,
atlas_policy_data,
format(
"{ranger_admin_user}:{ranger_admin_passwd}"))
# Get Ranger Atlas default policy for OPERATION resource
atlas_operation_policy_response = ranger_api_functions.get_ranger_service_default_policy(
ranger_admin_url, params.ranger_atlas_service_name,
format("{ranger_admin_user}:{ranger_admin_passwd}"), ['operation'])
if atlas_operation_policy_response:
beacon_atlas_user_present = ranger_api_functions.check_user_policy(
atlas_operation_policy_response, get_beacon_atlas_user)
if not beacon_atlas_user_present:
# Updating beacon atlas user in Ranger Atlas default policy for operation resource
atlas_operation_policy_id = atlas_operation_policy_response['id']
beacon_atlas_user_policy_item = {'groups': [], 'conditions': [],
'users': [get_beacon_atlas_user],
'accesses': [{'type': 'read', 'isAllowed': True},
{'type': 'create', 'isAllowed': True},
{'type': 'update', 'isAllowed': True},
{'type': 'delete', 'isAllowed': True},
{'type': 'all', 'isAllowed': True}]}
atlas_operation_policy_data = ranger_api_functions.update_policy_item(
atlas_operation_policy_response, beacon_atlas_user_policy_item)
atlas_operation_policy_update_response = ranger_api_functions.update_policy(
ranger_admin_url, atlas_operation_policy_id, atlas_operation_policy_data,
format("{ranger_admin_user}:{ranger_admin_passwd}"))
except Exception as e:
show_logs(params.beacon_log_dir, params.beacon_user)
if action == 'stop':
try:
Execute(format('{beacon_home}/bin/beacon stop'),
user=params.beacon_user,
path=params.hadoop_bin_dir,
environment=environment_dictionary)
except:
show_logs(params.beacon_log_dir, params.beacon_user)
File(params.server_pid_file, action='delete')
def create_directory(directory, scheme=None):
import params
if (scheme is None or scheme == ''):
if params.is_hdfs_installed:
scheme = 'hdfs'
else:
scheme = 'file'
Logger.info("Creating directory {0}:/{1}".format(scheme, directory))
if scheme == 'file':
Directory(directory,
owner=params.beacon_user,
create_parents=True,
mode=0755,
cd_access="a")
elif scheme == 'hdfs':
beacon_utils.create_hdfs_directory(directory, params.beacon_user, 0775)
params.HdfsResource(None, action="execute")
def download_mysql_driver():
import params
if params.jdbc_jar_name is None:
raise Fail("Mysql JDBC driver not installed on ambari-server")
File(
params.mysql_driver_target,
content=DownloadSource(params.driver_source),
mode=0644
)
| 65.926882 | 151 | 0.479123 | [
"Apache-2.0"
] | aries-demos/dataops | stacks/XIAOMATECH/1.0/services/BEACON/package/scripts/beacon.py | 30,656 | Python |
import pandas as pd
data=pd.read_csv("C:/Users/user/Documents/API_NY.GDP.PCAP.CD_DS2_en_csv_v2_1068945.csv") #your raw data obtained from world bank
import pandas as pd
import matplotlib.pyplot as plt
fulldataonly=data.dropna()
listofcountry=fulldataonly['Country Name']
listofcountry=list(listofcountry)
def findcountryrow(country):
for i in range(len(data['Country Name'])):
if data['Country Name'][i]==country:
return i
else:
print("error, country not found") # find which row is the country
listyear=list(range(1960,2018))
x=[]
y=[]
mydata=[]
#for country in range(len(listofcountry)):
# for year in listyear:
# y0=data.loc[findcountryrow(listofcountry[country]),str(year)]
# y1=data.loc[findcountryrow(listofcountry[country]),str(year+1)]
# delta=(y1-y0)/y0
# x.append(y0)
# y.append(delta)
# mydata.append([y0,delta])
fulllistofcountry=data['Country Name']
fulllistofcountry=list(fulllistofcountry)
for country in range(len(fulllistofcountry)):
for year in listyear:
if (pd.notnull(data.loc[country,str(year)]))&(pd.notnull(data.loc[country,str(year+1)])):
y0=data.loc[country,str(year)]
y1=data.loc[country,str(year+1)]
delta=((y1-y0)/y0)*100
x.append(y0)
y.append(delta)
mydata.append([y0,delta])
mydata.sort(key=lambda x: x[0])
count=0
GDP, myGDP=[],[]
Growth, myGrowth=[],[]
mysd=[]
naverage=500
averagedatax,averagedatay=[],[]
import statistics as s
for i in range(len(mydata)):
if count<naverage:
GDP.append(mydata[i][0])
Growth.append(mydata[i][1])
count+=1
if count==naverage:
myGDP=s.mean(GDP)
myGrowth=s.mean(Growth)
mysd.append(s.stdev(Growth))
averagedatax.append(myGDP)
averagedatay.append(myGrowth)
count=0
GDP=[]
Growth=[]
if i==len(mydata)-1:
myGDP=s.mean(GDP)
myGrowth=s.mean(Growth)
mysd.append(s.stdev(Growth))
averagedatax.append(myGDP)
averagedatay.append(myGrowth)
plt.xscale('log')
plt.xlim(100,200000)
plt.xlabel(' GDP per capita in US dollar',size=15)
plt.ylabel('GDP growth rate %',size=15)
plt.title('Dependence of Economic Growth Rate with GDP per capita',size=15)
plt.scatter(averagedatax,averagedatay)
# histogram=mydata[0:1800]
# per=[]
# for gdp, percentage in histogram:
# per.append(percentage)
# plt.xlim(-50,60)
# plt.xlabel('GDP per capita Growth %',size=15)
# plt.ylabel('Density Function',size=15)
# plt.title('Economic Growth for different countries for 1960-2018', size=15)
# plt.hist(x=per, bins='auto', density=True)
| 29.268817 | 129 | 0.649522 | [
"MIT"
] | ph7klw76/Data_science_project | Economic Growth & GDP per capita.py | 2,722 | Python |
# Monster Hot Air Balloon | (2435553)
if sm.getSkillByItem() == 0:# Check whether item has an vehicleID stored, 0 if false.
sm.chat("An Error occurred whilst trying to find the mount.")
elif sm.hasSkill(sm.getSkillByItem()):
sm.chat("You already have the 'Monster Hot Air Balloon' mount.")
else:
sm.consumeItem()
sm.giveSkill(sm.getSkillByItem())
sm.chat("Successfully added the 'Monster Hot Air Balloon' mount.")
sm.dispose()
| 40.909091 | 86 | 0.708889 | [
"MIT"
] | Bia10/MapleEllinel-v203.4 | scripts/item/consume_2435553.py | 450 | Python |
import time
from dataclasses import dataclass
import jwt
from util.enum_util import EnumBase
class Role(EnumBase):
USER = "USER"
ADMIN = "ADMIN"
class Perm(EnumBase):
NONE = "NONE"
READ_MSG = "READ_MSG"
WRITE_MSG = "WRITE_MSG"
@dataclass
class Identity:
user: str
role: Role.to_enum()
perm_mapping = {
Role.USER: [Perm.READ_MSG],
Role.ADMIN: [Perm.READ_MSG, Perm.WRITE_MSG],
}
def has_permission(self, perm: Perm) -> bool:
return perm in self.perm_mapping[self.role]
class JWTAuthenticator(object):
ACCESS_JWT_ALGORITHM = "HS256"
@classmethod
def dump_access_token(cls, key: str, identity: Identity, exp: int) -> str:
current_ts = int(time.time())
return jwt.encode(
payload=dict(
user=identity.user,
role=identity.role,
nbf=current_ts - 300, # not before
exp=current_ts + exp,
),
key=key,
algorithm=cls.ACCESS_JWT_ALGORITHM,
)
@classmethod
def load_access_token(cls, key: str, access_token: str) -> Identity:
payload = jwt.decode(
jwt=access_token, key=key, algorithms=[cls.ACCESS_JWT_ALGORITHM]
)
return Identity(user=payload["user"], role=payload["role"])
| 23.333333 | 78 | 0.605263 | [
"MIT"
] | pkyosx/fastapi-example | fastapi_example/util/auth_util.py | 1,330 | Python |
# this works around a path issue with just calling
# coverage run -m doctest -v <rst-file>
import doctest
import sys
fails = 0
for filename in [
"tuples.rst",
"functions.rst",
"symbolic.rst",
"simplification.rst",
"differentiation.rst",
"symbolic_tuples.rst",
]:
result = doctest.testfile(filename)
fails += result.failed
if fails:
sys.exit(1)
| 17.454545 | 50 | 0.661458 | [
"MIT"
] | jtauber/functional-differential-geometry | run_doctests.py | 384 | Python |
"""
The various serializers.
Pyro - Python Remote Objects. Copyright by Irmen de Jong ([email protected]).
"""
import array
import builtins
import uuid
import logging
import struct
import datetime
import decimal
import numbers
import inspect
import marshal
import json
import serpent
import msgpack
from . import errors
__all__ = ["SerializerBase", "SerpentSerializer", "JsonSerializer", "MarshalSerializer", "MsgpackSerializer",
"serializers", "serializers_by_id"]
log = logging.getLogger("Pyro5.serializers")
if '-' in serpent.__version__:
ver = serpent.__version__.split('-', 1)[0]
else:
ver = serpent.__version__
ver = tuple(map(int, ver.split(".")))
if ver < (1, 27):
raise RuntimeError("requires serpent 1.27 or better")
if msgpack.version < (0, 5, 2):
raise RuntimeError("requires msgpack 0.5.2 or better")
all_exceptions = {}
for name, t in vars(builtins).items():
if type(t) is type and issubclass(t, BaseException):
all_exceptions[name] = t
for name, t in vars(errors).items():
if type(t) is type and issubclass(t, errors.PyroError):
all_exceptions[name] = t
def pyro_class_serpent_serializer(obj, serializer, stream, level):
# Override the default way that a Pyro URI/proxy/daemon is serialized.
# Because it defines a __getstate__ it would otherwise just become a tuple,
# and not be deserialized as a class.
d = SerializerBase.class_to_dict(obj)
serializer.ser_builtins_dict(d, stream, level)
def serialize_pyro_object_to_dict(obj):
return {
"__class__": "{:s}.{:s}".format(obj.__module__, obj.__class__.__name__),
"state": obj.__getstate__()
}
class SerializerBase(object):
"""Base class for (de)serializer implementations (which must be thread safe)"""
serializer_id = 0 # define uniquely in subclass
__custom_class_to_dict_registry = {}
__custom_dict_to_class_registry = {}
def loads(self, data):
raise NotImplementedError("implement in subclass")
def loadsCall(self, data):
raise NotImplementedError("implement in subclass")
def dumps(self, data):
raise NotImplementedError("implement in subclass")
def dumpsCall(self, obj, method, vargs, kwargs):
raise NotImplementedError("implement in subclass")
@classmethod
def register_type_replacement(cls, object_type, replacement_function):
raise NotImplementedError("implement in subclass")
def _convertToBytes(self, data):
if type(data) is bytearray:
return bytes(data)
if type(data) is memoryview:
return data.tobytes()
return data
@classmethod
def register_class_to_dict(cls, clazz, converter, serpent_too=True):
"""Registers a custom function that returns a dict representation of objects of the given class.
The function is called with a single parameter; the object to be converted to a dict."""
cls.__custom_class_to_dict_registry[clazz] = converter
if serpent_too:
try:
def serpent_converter(obj, serializer, stream, level):
d = converter(obj)
serializer.ser_builtins_dict(d, stream, level)
serpent.register_class(clazz, serpent_converter)
except errors.ProtocolError:
pass
@classmethod
def unregister_class_to_dict(cls, clazz):
"""Removes the to-dict conversion function registered for the given class. Objects of the class
will be serialized by the default mechanism again."""
if clazz in cls.__custom_class_to_dict_registry:
del cls.__custom_class_to_dict_registry[clazz]
try:
serpent.unregister_class(clazz)
except errors.ProtocolError:
pass
@classmethod
def register_dict_to_class(cls, classname, converter):
"""
Registers a custom converter function that creates objects from a dict with the given classname tag in it.
The function is called with two parameters: the classname and the dictionary to convert to an instance of the class.
"""
cls.__custom_dict_to_class_registry[classname] = converter
@classmethod
def unregister_dict_to_class(cls, classname):
"""
Removes the converter registered for the given classname. Dicts with that classname tag
will be deserialized by the default mechanism again.
"""
if classname in cls.__custom_dict_to_class_registry:
del cls.__custom_dict_to_class_registry[classname]
@classmethod
def class_to_dict(cls, obj):
"""
Convert a non-serializable object to a dict. Partly borrowed from serpent.
"""
for clazz in cls.__custom_class_to_dict_registry:
if isinstance(obj, clazz):
return cls.__custom_class_to_dict_registry[clazz](obj)
if type(obj) in (set, dict, tuple, list):
# we use a ValueError to mirror the exception type returned by serpent and other serializers
raise ValueError("can't serialize type " + str(obj.__class__) + " into a dict")
if hasattr(obj, "_pyroDaemon"):
obj._pyroDaemon = None
if isinstance(obj, BaseException):
# special case for exceptions
return {
"__class__": obj.__class__.__module__ + "." + obj.__class__.__name__,
"__exception__": True,
"args": obj.args,
"attributes": vars(obj) # add custom exception attributes
}
try:
value = obj.__getstate__()
except AttributeError:
pass
else:
if isinstance(value, dict):
return value
try:
value = dict(vars(obj)) # make sure we can serialize anything that resembles a dict
value["__class__"] = obj.__class__.__module__ + "." + obj.__class__.__name__
return value
except TypeError:
if hasattr(obj, "__slots__"):
# use the __slots__ instead of the vars dict
value = {}
for slot in obj.__slots__:
value[slot] = getattr(obj, slot)
value["__class__"] = obj.__class__.__module__ + "." + obj.__class__.__name__
return value
else:
raise errors.SerializeError("don't know how to serialize class " + str(obj.__class__) +
" using serializer " + str(cls.__name__) +
". Give it vars() or an appropriate __getstate__")
@classmethod
def dict_to_class(cls, data):
"""
Recreate an object out of a dict containing the class name and the attributes.
Only a fixed set of classes are recognized.
"""
from . import core, client, server # XXX circular
classname = data.get("__class__", "<unknown>")
if isinstance(classname, bytes):
classname = classname.decode("utf-8")
if classname in cls.__custom_dict_to_class_registry:
converter = cls.__custom_dict_to_class_registry[classname]
return converter(classname, data)
if "__" in classname:
raise errors.SecurityError("refused to deserialize types with double underscores in their name: " + classname)
# for performance, the constructors below are hardcoded here instead of added on a per-class basis to the dict-to-class registry
if classname == "Pyro5.core.URI":
uri = core.URI.__new__(core.URI)
uri.__setstate__(data["state"])
return uri
elif classname == "Pyro5.client.Proxy":
proxy = client.Proxy.__new__(client.Proxy)
proxy.__setstate__(data["state"])
return proxy
elif classname == "Pyro5.server.Daemon":
daemon = server.Daemon.__new__(server.Daemon)
daemon.__setstate__(data["state"])
return daemon
elif classname.startswith("Pyro5.util."):
if classname == "Pyro5.util.SerpentSerializer":
return SerpentSerializer()
elif classname == "Pyro5.util.MarshalSerializer":
return MarshalSerializer()
elif classname == "Pyro5.util.JsonSerializer":
return JsonSerializer()
elif classname == "Pyro5.util.MsgpackSerializer":
return MsgpackSerializer()
elif classname.startswith("Pyro5.errors."):
errortype = getattr(errors, classname.split('.', 2)[2])
if issubclass(errortype, errors.PyroError):
return SerializerBase.make_exception(errortype, data)
elif classname == "struct.error":
return SerializerBase.make_exception(struct.error, data)
elif classname == "Pyro5.core._ExceptionWrapper":
ex = data["exception"]
if isinstance(ex, dict) and "__class__" in ex:
ex = SerializerBase.dict_to_class(ex)
return core._ExceptionWrapper(ex)
elif data.get("__exception__", False):
if classname in all_exceptions:
return SerializerBase.make_exception(all_exceptions[classname], data)
# python 2.x: exceptions.ValueError
# python 3.x: builtins.ValueError
# translate to the appropriate namespace...
namespace, short_classname = classname.split('.', 1)
if namespace in ("builtins", "exceptions"):
exceptiontype = getattr(builtins, short_classname)
if issubclass(exceptiontype, BaseException):
return SerializerBase.make_exception(exceptiontype, data)
elif namespace == "sqlite3" and short_classname.endswith("Error"):
import sqlite3
exceptiontype = getattr(sqlite3, short_classname)
if issubclass(exceptiontype, BaseException):
return SerializerBase.make_exception(exceptiontype, data)
log.warning("unsupported serialized class: " + classname)
raise errors.SerializeError("unsupported serialized class: " + classname)
@staticmethod
def make_exception(exceptiontype, data):
ex = exceptiontype(*data["args"])
if "attributes" in data:
# restore custom attributes on the exception object
for attr, value in data["attributes"].items():
setattr(ex, attr, value)
return ex
def recreate_classes(self, literal):
t = type(literal)
if t is set:
return {self.recreate_classes(x) for x in literal}
if t is list:
return [self.recreate_classes(x) for x in literal]
if t is tuple:
return tuple(self.recreate_classes(x) for x in literal)
if t is dict:
if "__class__" in literal:
return self.dict_to_class(literal)
result = {}
for key, value in literal.items():
result[key] = self.recreate_classes(value)
return result
return literal
def __eq__(self, other):
"""this equality method is only to support the unit tests of this class"""
return isinstance(other, SerializerBase) and vars(self) == vars(other)
def __ne__(self, other):
return not self.__eq__(other)
__hash__ = object.__hash__
class SerpentSerializer(SerializerBase):
"""(de)serializer that wraps the serpent serialization protocol."""
serializer_id = 1 # never change this
def dumpsCall(self, obj, method, vargs, kwargs):
return serpent.dumps((obj, method, vargs, kwargs), module_in_classname=True)
def dumps(self, data):
return serpent.dumps(data, module_in_classname=True)
def loadsCall(self, data):
obj, method, vargs, kwargs = serpent.loads(data)
vargs = self.recreate_classes(vargs)
kwargs = self.recreate_classes(kwargs)
return obj, method, vargs, kwargs
def loads(self, data):
return self.recreate_classes(serpent.loads(data))
@classmethod
def register_type_replacement(cls, object_type, replacement_function):
def custom_serializer(obj, serpent_serializer, outputstream, indentlevel):
replaced = replacement_function(obj)
if replaced is obj:
serpent_serializer.ser_default_class(replaced, outputstream, indentlevel)
else:
serpent_serializer._serialize(replaced, outputstream, indentlevel)
if object_type is type or not inspect.isclass(object_type):
raise ValueError("refusing to register replacement for a non-type or the type 'type' itself")
serpent.register_class(object_type, custom_serializer)
@classmethod
def dict_to_class(cls, data):
if data.get("__class__") == "float":
return float(data["value"]) # serpent encodes a float nan as a special class dict like this
return super(SerpentSerializer, cls).dict_to_class(data)
class MarshalSerializer(SerializerBase):
"""(de)serializer that wraps the marshal serialization protocol."""
serializer_id = 2 # never change this
def dumpsCall(self, obj, method, vargs, kwargs):
vargs = [self.convert_obj_into_marshallable(value) for value in vargs]
kwargs = {key: self.convert_obj_into_marshallable(value) for key, value in kwargs.items()}
return marshal.dumps((obj, method, vargs, kwargs))
def dumps(self, data):
return marshal.dumps(self.convert_obj_into_marshallable(data))
def loadsCall(self, data):
data = self._convertToBytes(data)
obj, method, vargs, kwargs = marshal.loads(data)
vargs = self.recreate_classes(vargs)
kwargs = self.recreate_classes(kwargs)
return obj, method, vargs, kwargs
def loads(self, data):
data = self._convertToBytes(data)
return self.recreate_classes(marshal.loads(data))
def convert_obj_into_marshallable(self, obj):
marshalable_types = (str, int, float, type(None), bool, complex, bytes, bytearray,
tuple, set, frozenset, list, dict)
if isinstance(obj, array.array):
if obj.typecode == 'c':
return obj.tostring()
if obj.typecode == 'u':
return obj.tounicode()
return obj.tolist()
if isinstance(obj, marshalable_types):
return obj
return self.class_to_dict(obj)
@classmethod
def class_to_dict(cls, obj):
if isinstance(obj, uuid.UUID):
return str(obj)
return super(MarshalSerializer, cls).class_to_dict(obj)
@classmethod
def register_type_replacement(cls, object_type, replacement_function):
pass # marshal serializer doesn't support per-type hooks
class JsonSerializer(SerializerBase):
"""(de)serializer that wraps the json serialization protocol."""
serializer_id = 3 # never change this
__type_replacements = {}
def dumpsCall(self, obj, method, vargs, kwargs):
data = {"object": obj, "method": method, "params": vargs, "kwargs": kwargs}
data = json.dumps(data, ensure_ascii=False, default=self.default)
return data.encode("utf-8")
def dumps(self, data):
data = json.dumps(data, ensure_ascii=False, default=self.default)
return data.encode("utf-8")
def loadsCall(self, data):
data = self._convertToBytes(data).decode("utf-8")
data = json.loads(data)
vargs = self.recreate_classes(data["params"])
kwargs = self.recreate_classes(data["kwargs"])
return data["object"], data["method"], vargs, kwargs
def loads(self, data):
data = self._convertToBytes(data).decode("utf-8")
return self.recreate_classes(json.loads(data))
def default(self, obj):
replacer = self.__type_replacements.get(type(obj), None)
if replacer:
obj = replacer(obj)
if isinstance(obj, set):
return tuple(obj) # json module can't deal with sets so we make a tuple out of it
if isinstance(obj, uuid.UUID):
return str(obj)
if isinstance(obj, (datetime.datetime, datetime.date)):
return obj.isoformat()
if isinstance(obj, decimal.Decimal):
return str(obj)
if isinstance(obj, array.array):
if obj.typecode == 'c':
return obj.tostring()
if obj.typecode == 'u':
return obj.tounicode()
return obj.tolist()
return self.class_to_dict(obj)
@classmethod
def register_type_replacement(cls, object_type, replacement_function):
if object_type is type or not inspect.isclass(object_type):
raise ValueError("refusing to register replacement for a non-type or the type 'type' itself")
cls.__type_replacements[object_type] = replacement_function
class MsgpackSerializer(SerializerBase):
"""(de)serializer that wraps the msgpack serialization protocol."""
serializer_id = 4 # never change this
__type_replacements = {}
def dumpsCall(self, obj, method, vargs, kwargs):
return msgpack.packb((obj, method, vargs, kwargs), use_bin_type=True, default=self.default)
def dumps(self, data):
return msgpack.packb(data, use_bin_type=True, default=self.default)
def loadsCall(self, data):
return msgpack.unpackb(self._convertToBytes(data), raw=False, object_hook=self.object_hook)
def loads(self, data):
return msgpack.unpackb(self._convertToBytes(data), raw=False, object_hook=self.object_hook, ext_hook=self.ext_hook)
def default(self, obj):
replacer = self.__type_replacements.get(type(obj), None)
if replacer:
obj = replacer(obj)
if isinstance(obj, set):
return tuple(obj) # msgpack module can't deal with sets so we make a tuple out of it
if isinstance(obj, uuid.UUID):
return str(obj)
if isinstance(obj, bytearray):
return bytes(obj)
if isinstance(obj, complex):
return msgpack.ExtType(0x30, struct.pack("dd", obj.real, obj.imag))
if isinstance(obj, datetime.datetime):
if obj.tzinfo:
raise errors.SerializeError("msgpack cannot serialize datetime with timezone info")
return msgpack.ExtType(0x32, struct.pack("d", obj.timestamp()))
if isinstance(obj, datetime.date):
return msgpack.ExtType(0x33, struct.pack("l", obj.toordinal()))
if isinstance(obj, decimal.Decimal):
return str(obj)
if isinstance(obj, numbers.Number):
return msgpack.ExtType(0x31, str(obj).encode("ascii")) # long
if isinstance(obj, array.array):
if obj.typecode == 'c':
return obj.tostring()
if obj.typecode == 'u':
return obj.tounicode()
return obj.tolist()
return self.class_to_dict(obj)
def object_hook(self, obj):
if "__class__" in obj:
return self.dict_to_class(obj)
return obj
def ext_hook(self, code, data):
if code == 0x30:
real, imag = struct.unpack("dd", data)
return complex(real, imag)
if code == 0x31:
return int(data)
if code == 0x32:
return datetime.datetime.fromtimestamp(struct.unpack("d", data)[0])
if code == 0x33:
return datetime.date.fromordinal(struct.unpack("l", data)[0])
raise errors.SerializeError("invalid ext code for msgpack: " + str(code))
@classmethod
def register_type_replacement(cls, object_type, replacement_function):
if object_type is type or not inspect.isclass(object_type):
raise ValueError("refusing to register replacement for a non-type or the type 'type' itself")
cls.__type_replacements[object_type] = replacement_function
"""The various serializers that are supported"""
serializers = {
"serpent": SerpentSerializer(),
"marshal": MarshalSerializer(),
"json": JsonSerializer(),
"msgpack": MsgpackSerializer()
}
"""The available serializers by their internal id"""
serializers_by_id = {ser.serializer_id: ser for ser in serializers.values()}
| 40.487129 | 136 | 0.638316 | [
"MIT"
] | gst/Pyro5 | Pyro5/serializers.py | 20,446 | Python |
# Exercício número 3 da lista
n1 = int(input('DIgite um valor:'))
n2 = int(input('Digite outro valor:'))
soma = n1+n2
print('A soma entre {} e {} é {}'.format(n1, n2, soma)) | 34.6 | 55 | 0.641618 | [
"MIT"
] | FelipeDreissig/Prog-em-Py---CursoEmVideo | Mundo 1/Ex003 - soma.py | 176 | Python |
from django.contrib.sitemaps import Sitemap
from main.models import Algo, Code
class AlgoSitemap(Sitemap):
changefreq = "daily"
priority = 1
def items(self):
return Algo.objects.all()
def lastmod(self, obj):
return obj.created_at
def location(self, obj):
return "/" + obj.slug
class CodeSitemap(Sitemap):
changefreq = "daily"
priority = 1
def items(self):
return Code.objects.all()
def lastmod(self, obj):
return obj.algo.created_at
def location(self, obj):
return "/code/%s/%s" % (obj.id, obj.algo.slug)
| 20.066667 | 54 | 0.626246 | [
"Apache-2.0"
] | algorithms-gad/algoBook | main/algoSitemap.py | 602 | Python |
"""
Meta thinking: python objects & introspection
usefull documentation:
http://python-3-patterns-idioms-test.readthedocs.org/en/latest/Metaprogramming.html
"""
import inspect
import pkgutil
from importlib import import_module
from types import ModuleType
from typing import Any, Callable, Dict, List, Optional, Type
from restapi.config import BACKEND_PACKAGE, CUSTOM_PACKAGE
from restapi.utilities import print_and_exit
from restapi.utilities.logs import log
class Meta:
"""Utilities with meta in mind"""
@staticmethod
def get_classes_from_module(module: ModuleType) -> Dict[str, Type[Any]]:
"""
Find classes inside a python module file.
"""
try:
return {
name: cls
for name, cls in module.__dict__.items()
if isinstance(cls, type)
}
except AttributeError:
log.warning("Could not find any class in module {}", module)
return {}
@staticmethod
def get_new_classes_from_module(module: ModuleType) -> Dict[str, Type[Any]]:
"""
Skip classes not originated inside the module.
"""
classes = {}
for name, value in Meta.get_classes_from_module(module).items():
if module.__name__ in value.__module__:
classes[name] = value
return classes
# Should return `from types import ModuleType` -> Optional[ModuleType]
@staticmethod
def get_module_from_string(
modulestring: str, exit_on_fail: bool = False
) -> Optional[ModuleType]:
"""
Getting a module import
when your module is stored as a string in a variable
"""
try:
return import_module(modulestring)
except ModuleNotFoundError as e:
if exit_on_fail:
log.error(e)
raise e
return None
except Exception as e: # pragma: no cover
if exit_on_fail:
log.error(e)
raise e
log.error("Module {} not found.\nError: {}", modulestring, e)
return None
@staticmethod
def get_self_reference_from_args(*args: Any) -> Optional[Any]:
"""
Useful in decorators:
being able to call the internal method by getting
the 'self' reference from the decorated method
(when it's there)
"""
if len(args) > 0:
candidate_as_self = args[0]
cls_attribute = getattr(candidate_as_self, "__class__", None)
if cls_attribute is not None and inspect.isclass(cls_attribute):
return args[0]
return None
@staticmethod
def import_models(
name: str, package: str, mandatory: bool = False
) -> Dict[str, Type[Any]]:
if package == BACKEND_PACKAGE:
module_name = f"{package}.connectors.{name}.models"
else:
module_name = f"{package}.models.{name}"
try:
module = Meta.get_module_from_string(module_name, exit_on_fail=True)
except Exception as e:
module = None
if mandatory:
log.critical(e)
if not module:
if mandatory:
print_and_exit("Cannot load {} models from {}", name, module_name)
return {}
return Meta.get_new_classes_from_module(module)
@staticmethod
def get_celery_tasks(package_name: str) -> List[Callable[..., Any]]:
"""
Extract all celery tasks from a module.
Celery tasks are functions decorated by @CeleryExt.celery_app.task(...)
This decorator transform the function into a class child of
celery.local.PromiseProxy
"""
tasks: List[Callable[..., Any]] = []
# package = tasks folder
package = Meta.get_module_from_string(package_name)
if package is None:
return tasks
# get all modules in package (i.e. py files)
path = package.__path__
for _, module_name, ispkg in pkgutil.iter_modules(path):
# skip modules (i.e. subfolders)
if ispkg: # pragma: no cover
continue
module_path = f"{package_name}.{module_name}"
log.debug("Loading module '{}'", module_path)
# convert file name in submodule, i.e.
# tasks.filename
submodule = Meta.get_module_from_string(
module_path,
exit_on_fail=True,
)
# get all functions in py file
functions = inspect.getmembers(submodule)
for func in functions:
obj_type = type(func[1])
if obj_type.__module__ != "celery.local":
continue
# This was a dict name => func
# tasks[func[0]] = func[1]
# Now it is a list
tasks.append(func[1])
return tasks
@staticmethod
def get_class(module_relpath: str, class_name: str) -> Optional[Any]:
abspath = f"{CUSTOM_PACKAGE}.{module_relpath}"
module = Meta.get_module_from_string(abspath)
if module is None:
log.debug("{} path does not exist", abspath)
return None
if not hasattr(module, class_name):
return None
return getattr(module, class_name)
| 30.398876 | 83 | 0.582887 | [
"MIT"
] | rapydo/http-api | restapi/utilities/meta.py | 5,411 | Python |
from core.himesis import Himesis, HimesisPreConditionPatternLHS
import uuid
class HUnitR06_IsolatedLHS(HimesisPreConditionPatternLHS):
def __init__(self):
"""
Creates the himesis graph representing the AToM3 model HUnitR06_IsolatedLHS
"""
# Flag this instance as compiled now
self.is_compiled = True
super(HUnitR06_IsolatedLHS, self).__init__(name='HUnitR06_IsolatedLHS', num_nodes=0, edges=[])
# Add the edges
self.add_edges([])
# Set the graph attributes
self["mm__"] = ['MT_pre__FamiliesToPersonsMM', 'MoTifRule']
self["MT_constraint__"] = """return True"""
self["name"] = """"""
self["GUID__"] = uuid.uuid3(uuid.NAMESPACE_DNS,'HUnitR06_IsolatedLHS')
self["equations"] = []
# Set the node attributes
# match class PhysicalNode(6.0.m.0PhysicalNode) node
self.add_node()
self.vs[0]["MT_pre__attr1"] = """return True"""
self.vs[0]["MT_label__"] = """1"""
self.vs[0]["mm__"] = """MT_pre__PhysicalNode"""
self.vs[0]["GUID__"] = uuid.uuid3(uuid.NAMESPACE_DNS,'6.0.m.0PhysicalNode')
# match class Partition(6.0.m.1Partition) node
self.add_node()
self.vs[1]["MT_pre__attr1"] = """return True"""
self.vs[1]["MT_label__"] = """2"""
self.vs[1]["mm__"] = """MT_pre__Partition"""
self.vs[1]["GUID__"] = uuid.uuid3(uuid.NAMESPACE_DNS,'6.0.m.1Partition')
# define evaluation methods for each apply class.
def eval_attr11(self, attr_value, this):
return True
def eval_attr12(self, attr_value, this):
return True
def constraint(self, PreNode, graph):
return True
| 29.921569 | 96 | 0.700524 | [
"MIT"
] | levilucio/SyVOLT | GM2AUTOSAR_MM/Properties/unit_contracts/HUnitR06_IsolatedLHS.py | 1,526 | Python |
# Copyright (C) 2018-2022 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import numpy as np
from openvino.tools.mo.ops.eye import MXEye
from openvino.tools.mo.front.extractor import FrontExtractorOp
from openvino.tools.mo.front.mxnet.extractors.utils import get_mxnet_layer_attrs
class EyeExtractor(FrontExtractorOp):
op = '_eye'
enabled = True
@classmethod
def extract(cls, node):
attrs = get_mxnet_layer_attrs(node.symbol_dict)
num_rows = attrs.int("N")
num_columns = attrs.int("M", num_rows)
if num_columns is None or num_columns == 0:
num_columns = num_rows
diagonal_index = attrs.int("k", 0)
out_type = attrs.dtype("dtype", np.float32)
new_attrs = {'num_rows': num_rows, 'num_columns': num_columns, 'diagonal_index': diagonal_index, 'output_type': out_type}
MXEye.update_node_stat(node, new_attrs)
return cls.enabled
| 34.666667 | 129 | 0.700855 | [
"Apache-2.0"
] | opencv/dldt | tools/mo/openvino/tools/mo/front/mxnet/eye_ext.py | 936 | Python |
__copyright__ = """
Copyright (C) 2009-2017 Andreas Kloeckner
Copyright (C) 2014-2017 Aaron Meurer
"""
__license__ = """
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
import urwid
import bdb
import gc
import os
import sys
from itertools import count
from functools import partial
from types import TracebackType
from pudb.lowlevel import decode_lines, ui_log
from pudb.settings import load_config, save_config
CONFIG = load_config()
save_config(CONFIG)
HELP_HEADER = r"""
Key Assignments: Use Arrow Down/Up or Page Down/Up to scroll.
"""
HELP_MAIN = r"""
Keys:
Ctrl-p - edit preferences
n - step over ("next")
s - step into
c - continue
r/f - finish current function
t - run to cursor
e - show traceback [post-mortem or in exception state]
b - set/clear breakpoint
Ctrl-e - open file at current line to edit with $EDITOR
H - move to current line (bottom of stack)
u - move up one stack frame
d - move down one stack frame
o - show console/output screen
m - open module
j/k - down/up
l/h - right/left
Ctrl-f/b - page down/up
Ctrl-d/u - page down/up
G/g - end/home
L - show (file/line) location / go to line
/ - search
,/. - search next/previous
V - focus variables
S - focus stack
B - focus breakpoint list
C - focus code
F1/? - show this help screen
q - quit
Ctrl-r - reload breakpoints from saved-breakpoints file
Ctrl-c - when in continue mode, break back to PuDB
Ctrl-l - redraw screen
Shell-related:
! - open the external shell (configured in the settings)
Ctrl-x - toggle the internal shell focus
+/- - grow/shrink inline shell (active in command line history)
_/= - minimize/maximize inline shell (active in command line history)
Ctrl-v - insert newline
Ctrl-n/p - browse command line history
Tab - yes, there is (simple) tab completion
"""
HELP_SIDE = r"""
Sidebar-related (active in sidebar):
+/- - grow/shrink sidebar
_/= - minimize/maximize sidebar
[/] - grow/shrink relative size of active sidebar box
Keys in variables list:
\/enter/space - expand/collapse
h - collapse
l - expand
d/t/r/s/i/c - show default/type/repr/str/id/custom for this variable
H - toggle highlighting
@ - toggle repetition at top
* - cycle attribute visibility: public/_private/__dunder__
m - toggle method visibility
w - toggle line wrapping
n/insert - add new watch expression
e - edit options (also to delete)
Keys in stack list:
enter - jump to frame
Ctrl-e - open file at line to edit with $EDITOR
Keys in breakpoints list:
enter - jump to breakpoint
b - toggle breakpoint
d - delete breakpoint
e - edit breakpoint
Other keys:
j/k - down/up
l/h - right/left
Ctrl-f/b - page down/up
Ctrl-d/u - page down/up
G/g - end/home
V - focus variables
S - focus stack
B - focus breakpoint list
C - focus code
F1/? - show this help screen
q - quit
Ctrl-l - redraw screen
"""
HELP_LICENSE = r"""
License:
--------
PuDB is licensed to you under the MIT/X Consortium license:
Copyright (c) 2009-16 Andreas Kloeckner and contributors
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
"""
# {{{ debugger interface
class Debugger(bdb.Bdb):
def __init__(self, stdin=None, stdout=None, term_size=None, steal_output=False,
**kwargs):
# Pass remaining kwargs to python debugger framework
bdb.Bdb.__init__(self, **kwargs)
self.ui = DebuggerUI(self, stdin=stdin, stdout=stdout, term_size=term_size)
self.steal_output = steal_output
self.setup_state()
if steal_output:
raise NotImplementedError("output stealing")
from io import StringIO
self.stolen_output = sys.stderr = sys.stdout = StringIO()
sys.stdin = StringIO("") # avoid spurious hangs
from pudb.settings import load_breakpoints
for bpoint_descr in load_breakpoints():
self.set_break(*bpoint_descr)
# These (dispatch_line and set_continue) are copied from bdb with the
# patch from https://bugs.python.org/issue16482 applied. See
# https://github.com/inducer/pudb/pull/90.
def dispatch_line(self, frame):
if self.stop_here(frame) or self.break_here(frame):
self.user_line(frame)
if self.quitting:
raise bdb.BdbQuit
# Do not re-install the local trace when we are finished debugging,
# see issues 16482 and 7238.
if not sys.gettrace():
return None
return self.trace_dispatch
def set_continue(self):
# Don't stop except at breakpoints or when finished
self._set_stopinfo(self.botframe, None, -1)
if not self.breaks:
# no breakpoints; run without debugger overhead
sys.settrace(None)
frame = sys._getframe().f_back
while frame:
del frame.f_trace
if frame is self.botframe:
break
frame = frame.f_back
def set_trace(self, frame=None, as_breakpoint=None, paused=True):
"""Start debugging from `frame`.
If frame is not specified, debugging starts from caller's frame.
Unlike Bdb.set_trace(), this does not call self.reset(), which causes
the debugger to enter bdb source code. This also implements treating
set_trace() calls as breakpoints in the PuDB UI.
If as_breakpoint=True (the default), this call will be treated like a
breakpoint in the UI (you can press 'b' on it to disable breaking
here).
If paused=False, the debugger will not break here.
"""
if as_breakpoint is None:
if not paused:
as_breakpoint = False
else:
as_breakpoint = True
if frame is None:
frame = thisframe = sys._getframe().f_back
else:
thisframe = frame
# See pudb issue #52. If this works well enough we should upstream to
# stdlib bdb.py.
#self.reset()
while frame:
frame.f_trace = self.trace_dispatch
self.botframe = frame
frame = frame.f_back
thisframe_info = (
self.canonic(thisframe.f_code.co_filename), thisframe.f_lineno)
if thisframe_info not in self.set_traces or self.set_traces[thisframe_info]:
if as_breakpoint:
self.set_traces[thisframe_info] = True
if self.ui.source_code_provider is not None:
self.ui.set_source_code_provider(
self.ui.source_code_provider, force_update=True)
if paused:
self.set_step()
else:
self.set_continue()
sys.settrace(self.trace_dispatch)
else:
return
def save_breakpoints(self):
from pudb.settings import save_breakpoints
save_breakpoints([
bp
for fn, bp_lst in self.get_all_breaks().items()
for lineno in bp_lst
for bp in self.get_breaks(fn, lineno)
if not bp.temporary])
def enter_post_mortem(self, exc_tuple):
self.post_mortem = True
def setup_state(self):
self.bottom_frame = None
self.mainpyfile = ""
self._wait_for_mainpyfile = False
self.current_bp = None
self.post_mortem = False
# Mapping of (filename, lineno) to bool. If True, will stop on the
# set_trace() call at that location.
self.set_traces = {}
def restart(self):
from linecache import checkcache
checkcache()
self.ui.set_source_code_provider(NullSourceCodeProvider())
self.setup_state()
def do_clear(self, arg):
self.clear_bpbynumber(int(arg))
def set_frame_index(self, index):
self.curindex = index
if index < 0 or index >= len(self.stack):
return
self.curframe, lineno = self.stack[index]
filename = self.curframe.f_code.co_filename
import linecache
if not linecache.getlines(filename):
code = self.curframe.f_globals.get("_MODULE_SOURCE_CODE")
if code is not None:
self.ui.set_current_line(lineno,
DirectSourceCodeProvider(
self.curframe.f_code.co_name, code))
else:
self.ui.set_current_line(lineno,
NullSourceCodeProvider())
else:
self.ui.set_current_line(lineno,
FileSourceCodeProvider(self, filename))
self.ui.update_var_view()
self.ui.update_stack()
self.ui.stack_list._w.set_focus(self.ui.translate_ui_stack_index(index))
@staticmethod
def open_file_to_edit(filename, line_number):
if not os.path.isfile(filename):
raise FileNotFoundError(f"'{filename}' not found or is not a file.")
if not line_number:
line_number = 1
editor = os.environ.get("EDITOR", "nano")
import subprocess
subprocess.call([editor, f"+{line_number}", filename], shell=False)
return filename
def move_up_frame(self):
if self.curindex > 0:
self.set_frame_index(self.curindex-1)
def move_down_frame(self):
if self.curindex < len(self.stack)-1:
self.set_frame_index(self.curindex+1)
def get_shortened_stack(self, frame, tb):
stack, index = self.get_stack(frame, tb)
for i, (s_frame, lineno) in enumerate(stack):
if s_frame is self.bottom_frame and index >= i:
stack = stack[i:]
index -= i
return stack, index
def interaction(self, frame, exc_tuple=None, show_exc_dialog=True):
if exc_tuple is None:
tb = None
elif isinstance(exc_tuple, TracebackType):
# For API compatibility with other debuggers, the second variable
# can be a traceback object. In that case, we need to retrieve the
# corresponding exception tuple.
tb = exc_tuple
exc, = (exc for exc in gc.get_referrers(tb)
if getattr(exc, "__traceback__", None) is tb)
exc_tuple = type(exc), exc, tb
else:
tb = exc_tuple[2]
if frame is None and tb is not None:
frame = tb.tb_frame
found_bottom_frame = False
walk_frame = frame
while True:
if walk_frame is self.bottom_frame:
found_bottom_frame = True
break
if walk_frame is None:
break
walk_frame = walk_frame.f_back
if not found_bottom_frame and not self.post_mortem:
return
self.stack, index = self.get_shortened_stack(frame, tb)
if self.post_mortem:
index = len(self.stack)-1
self.set_frame_index(index)
self.ui.call_with_ui(self.ui.interaction, exc_tuple,
show_exc_dialog=show_exc_dialog)
def get_stack_situation_id(self):
return str(id(self.stack[self.curindex][0].f_code))
def user_call(self, frame, argument_list):
"""This method is called when there is the remote possibility
that we ever need to stop in this function."""
if self._wait_for_mainpyfile:
return
if self.stop_here(frame):
self.interaction(frame)
def user_line(self, frame):
"""This function is called when we stop or break at this line."""
if "__exc_tuple__" in frame.f_locals:
del frame.f_locals["__exc_tuple__"]
if self._wait_for_mainpyfile:
if (self.mainpyfile != self.canonic(frame.f_code.co_filename)
or frame.f_lineno <= 0):
return
self._wait_for_mainpyfile = False
self.bottom_frame = frame
if self.get_break(self.canonic(frame.f_code.co_filename), frame.f_lineno):
self.current_bp = (
self.canonic(frame.f_code.co_filename), frame.f_lineno)
else:
self.current_bp = None
try:
self.ui.update_breakpoints()
self.interaction(frame)
except Exception:
self.ui.show_internal_exc_dlg(sys.exc_info())
def user_return(self, frame, return_value):
"""This function is called when a return trap is set here."""
if frame.f_code.co_name != "<module>":
frame.f_locals["__return__"] = return_value
if self._wait_for_mainpyfile:
if (self.mainpyfile != self.canonic(frame.f_code.co_filename)
or frame.f_lineno <= 0):
return
self._wait_for_mainpyfile = False
self.bottom_frame = frame
if "__exc_tuple__" not in frame.f_locals:
self.interaction(frame)
def user_exception(self, frame, exc_tuple):
"""This function is called if an exception occurs,
but only if we are to stop at or just below this level."""
frame.f_locals["__exc_tuple__"] = exc_tuple
if not self._wait_for_mainpyfile:
self.interaction(frame, exc_tuple)
def _runscript(self, filename):
# Provide separation from current __main__, which is likely
# pudb.__main__ run. Preserving its namespace is not important, and
# having the script share it ensures that, e.g., pickle can find
# types defined there:
# https://github.com/inducer/pudb/issues/331
import __main__
__main__.__dict__.clear()
__main__.__dict__.update({
"__name__": "__main__",
"__file__": filename,
"__builtins__": __builtins__,
})
# When bdb sets tracing, a number of call and line events happens
# BEFORE debugger even reaches user's code (and the exact sequence of
# events depends on python version). So we take special measures to
# avoid stopping before we reach the main script (see user_line and
# user_call for details).
self._wait_for_mainpyfile = 1
self.mainpyfile = self.canonic(filename)
statement = 'exec(compile(open("{}").read(), "{}", "exec"))'.format(
filename, filename)
# Set up an interrupt handler
from pudb import set_interrupt_handler
set_interrupt_handler()
# Implicitly runs in the namespace of __main__.
self.run(statement)
def _runmodule(self, module_name):
# This is basically stolen from the pdb._runmodule from CPython 3.8
# https://github.com/python/cpython/blob/a1d3be4623c8ec7069bd34ccdce336be9cdeb644/Lib/pdb.py#L1530
import runpy
mod_name, mod_spec, code = runpy._get_module_details(module_name)
self.mainpyfile = self.canonic(code.co_filename)
import __main__
__main__.__dict__.clear()
__main__.__dict__.update({
"__name__": "__main__",
"__file__": self.mainpyfile,
"__spec__": mod_spec,
"__builtins__": __builtins__,
"__package__": mod_spec.parent,
"__loader__": mod_spec.loader,
})
self._wait_for_mainpyfile = True
self.run(code)
# }}}
# UI stuff --------------------------------------------------------------------
from pudb.ui_tools import make_hotkey_markup, labelled_value, \
SelectableText, SignalWrap, StackFrame, BreakpointFrame
from pudb.var_view import FrameVarInfoKeeper
# {{{ display setup
try:
import curses
except ImportError:
curses = None
from urwid.raw_display import Screen as RawScreen
try:
from urwid.curses_display import Screen as CursesScreen
except ImportError:
CursesScreen = None
class ThreadsafeScreenMixin:
"""A Screen subclass that doesn't crash when running from a non-main thread."""
def signal_init(self):
"""Initialize signal handler, ignoring errors silently."""
try:
super().signal_init()
except ValueError:
pass
def signal_restore(self):
"""Restore default signal handler, ignoring errors silently."""
try:
super().signal_restore()
except ValueError:
pass
class ThreadsafeRawScreen(ThreadsafeScreenMixin, RawScreen):
pass
class ThreadsafeFixedSizeRawScreen(ThreadsafeScreenMixin, RawScreen):
def __init__(self, **kwargs):
self._term_size = kwargs.pop("term_size", None)
super().__init__(**kwargs)
def get_cols_rows(self):
if self._term_size is not None:
return self._term_size
else:
return 80, 24
if curses is not None:
class ThreadsafeCursesScreen(ThreadsafeScreenMixin, RawScreen):
pass
# }}}
# {{{ source code providers
class SourceCodeProvider:
def __ne__(self, other):
return not (self == other)
class NullSourceCodeProvider(SourceCodeProvider):
def __eq__(self, other):
return type(self) == type(other)
def identifier(self):
return "<no source code>"
def get_source_identifier(self):
return None
def clear_cache(self):
pass
def get_lines(self, debugger_ui):
from pudb.source_view import SourceLine
return [
SourceLine(debugger_ui, "<no source code available>"),
SourceLine(debugger_ui, ""),
SourceLine(debugger_ui, "If this is generated code and you would "
"like the source code to show up here,"),
SourceLine(debugger_ui, "add it to linecache.cache, like"),
SourceLine(debugger_ui, ""),
SourceLine(debugger_ui, " import linecache"),
SourceLine(debugger_ui, " linecache.cache[filename] = "
"(size, mtime, lines, fullname)"),
SourceLine(debugger_ui, ""),
SourceLine(debugger_ui, "You can also set the attribute "
"_MODULE_SOURCE_CODE in the module in which this function"),
SourceLine(debugger_ui, "was compiled to a string containing "
"the code."),
]
class FileSourceCodeProvider(SourceCodeProvider):
def __init__(self, debugger, file_name):
self.file_name = debugger.canonic(file_name)
def __eq__(self, other):
return type(self) == type(other) and self.file_name == other.file_name
def identifier(self):
return self.file_name
def get_source_identifier(self):
return self.file_name
def clear_cache(self):
from linecache import clearcache
clearcache()
def get_lines(self, debugger_ui):
from pudb.source_view import SourceLine, format_source
if self.file_name == "<string>":
return [SourceLine(debugger_ui, self.file_name)]
breakpoints = debugger_ui.debugger.get_file_breaks(self.file_name)[:]
breakpoints = [lineno for lineno in breakpoints if
any(bp.enabled
for bp in debugger_ui.debugger.get_breaks(self.file_name, lineno))]
breakpoints += [i for f, i in debugger_ui.debugger.set_traces if f
== self.file_name and debugger_ui.debugger.set_traces[f, i]]
try:
from linecache import getlines
lines = getlines(self.file_name)
return format_source(
debugger_ui, list(decode_lines(lines)), set(breakpoints))
except Exception:
from pudb.lowlevel import format_exception
debugger_ui.message("Could not load source file '{}':\n\n{}".format(
self.file_name, "".join(format_exception(sys.exc_info()))),
title="Source Code Load Error")
return [SourceLine(debugger_ui,
"Error while loading '%s'." % self.file_name)]
class DirectSourceCodeProvider(SourceCodeProvider):
def __init__(self, func_name, code):
self.function_name = func_name
self.code = code
def __eq__(self, other):
return (
type(self) == type(other)
and self.function_name == other.function_name
and self.code is other.code)
def identifier(self):
return "<source code of function %s>" % self.function_name
def get_source_identifier(self):
return None
def clear_cache(self):
pass
def get_lines(self, debugger_ui):
from pudb.source_view import format_source
lines = self.code.splitlines(True)
return format_source(debugger_ui, list(decode_lines(lines)), set())
# }}}
class DebuggerUI(FrameVarInfoKeeper):
# {{{ constructor
def __init__(self, dbg, stdin, stdout, term_size):
FrameVarInfoKeeper.__init__(self)
self.debugger = dbg
from urwid import AttrMap
from pudb.ui_tools import SearchController
self.search_controller = SearchController(self)
self.last_module_filter = ""
# {{{ build ui
# {{{ key bindings
def move_up(w, size, key):
w.keypress(size, "up")
def move_down(w, size, key):
w.keypress(size, "down")
def move_left(w, size, key):
w.keypress(size, "left")
def move_right(w, size, key):
w.keypress(size, "right")
def page_up(w, size, key):
w.keypress(size, "page up")
def page_down(w, size, key):
w.keypress(size, "page down")
def move_home(w, size, key):
w.keypress(size, "home")
def move_end(w, size, key):
w.keypress(size, "end")
def add_vi_nav_keys(widget):
widget.listen("k", move_up)
widget.listen("j", move_down)
widget.listen("h", move_left)
widget.listen("l", move_right)
widget.listen("ctrl b", page_up)
widget.listen("ctrl f", page_down)
widget.listen("ctrl u", page_up)
widget.listen("ctrl d", page_down)
widget.listen("g", move_home)
widget.listen("G", move_end)
def add_help_keys(widget, helpfunc):
widget.listen("f1", helpfunc)
widget.listen("?", helpfunc)
# }}}
# {{{ left/source column
self.source = urwid.SimpleListWalker([])
self.source_list = urwid.ListBox(self.source)
self.source_sigwrap = SignalWrap(self.source_list)
self.source_attr = urwid.AttrMap(self.source_sigwrap, "source")
self.source_hscroll_start = 0
self.cmdline_history = []
self.cmdline_history_position = -1
self.cmdline_contents = urwid.SimpleFocusListWalker([])
self.cmdline_list = urwid.ListBox(self.cmdline_contents)
self.cmdline_edit = urwid.Edit([
("command line prompt", ">>> ")
])
cmdline_edit_attr = urwid.AttrMap(self.cmdline_edit, "command line edit")
self.cmdline_edit_sigwrap = SignalWrap(
cmdline_edit_attr, is_preemptive=True)
def clear_cmdline_history(btn):
del self.cmdline_contents[:]
self.cmdline_edit_bar = urwid.Columns([
self.cmdline_edit_sigwrap,
("fixed", 10, AttrMap(
urwid.Button("Clear", clear_cmdline_history),
"command line clear button", "command line focused button"))
])
self.cmdline_pile = urwid.Pile([
("flow", urwid.Text("Command line: [Ctrl-X]")),
("weight", 1, urwid.AttrMap(self.cmdline_list, "command line output")),
("flow", self.cmdline_edit_bar),
])
self.cmdline_sigwrap = SignalWrap(
urwid.AttrMap(self.cmdline_pile, None, "focused sidebar")
)
self.cmdline_on = not CONFIG["hide_cmdline_win"]
self.cmdline_weight = 1
self.lhs_col = urwid.Pile([
("weight", 5, self.source_attr),
("weight", self.cmdline_weight if self.cmdline_on else 0,
self.cmdline_sigwrap),
])
# }}}
# {{{ right column
self.locals = urwid.SimpleListWalker([])
self.var_list = SignalWrap(
urwid.ListBox(self.locals))
self.stack_walker = urwid.SimpleListWalker([])
self.stack_list = SignalWrap(
urwid.ListBox(self.stack_walker))
self.bp_walker = urwid.SimpleListWalker([])
self.bp_list = SignalWrap(
urwid.ListBox(self.bp_walker))
self.rhs_col = urwid.Pile([
("weight", float(CONFIG["variables_weight"]), AttrMap(urwid.Pile([
("flow", urwid.Text(make_hotkey_markup("_Variables:"))),
AttrMap(self.var_list, "variables"),
]), None, "focused sidebar"),),
("weight", float(CONFIG["stack_weight"]), AttrMap(urwid.Pile([
("flow", urwid.Text(make_hotkey_markup("_Stack:"))),
AttrMap(self.stack_list, "stack"),
]), None, "focused sidebar"),),
("weight", float(CONFIG["breakpoints_weight"]), AttrMap(urwid.Pile([
("flow", urwid.Text(make_hotkey_markup("_Breakpoints:"))),
AttrMap(self.bp_list, "breakpoint"),
]), None, "focused sidebar"),),
])
self.rhs_col_sigwrap = SignalWrap(self.rhs_col)
def helpside(w, size, key):
help(HELP_HEADER + HELP_SIDE + HELP_MAIN + HELP_LICENSE)
add_vi_nav_keys(self.rhs_col_sigwrap)
add_help_keys(self.rhs_col_sigwrap, helpside)
# }}}
self.columns = urwid.Columns(
[
("weight", 1, self.lhs_col),
("weight", float(CONFIG["sidebar_width"]),
self.rhs_col_sigwrap),
],
dividechars=1)
self.caption = urwid.Text("")
header = urwid.AttrMap(self.caption, "header")
self.top = SignalWrap(urwid.Frame(
urwid.AttrMap(self.columns, "background"),
header))
# }}}
def change_rhs_box(name, index, direction, w, size, key):
from pudb.settings import save_config
weight = self.rhs_col.item_types[index][1]
if direction < 0:
if weight > 1/5:
weight /= 1.25
else:
if weight < 5:
weight *= 1.25
CONFIG[name+"_weight"] = weight
save_config(CONFIG)
self.rhs_col.item_types[index] = "weight", weight
self.rhs_col._invalidate()
# {{{ variables listeners
def get_inspect_info(id_path, read_only=False):
return (self.get_frame_var_info(read_only)
.get_inspect_info(id_path, read_only))
def collapse_current(var, pos, iinfo):
if iinfo.show_detail:
# collapse current variable
iinfo.show_detail = False
else:
# collapse parent/container variable
if var.parent is not None:
p_iinfo = get_inspect_info(var.parent.id_path)
p_iinfo.show_detail = False
return self.locals.index(var.parent)
return None
def change_var_state(w, size, key):
var, pos = self.var_list._w.get_focus()
if var is None:
return
iinfo = get_inspect_info(var.id_path)
focus_index = None
if key == "enter" or key == "\\" or key == " ":
iinfo.show_detail = not iinfo.show_detail
elif key == "h":
focus_index = collapse_current(var, pos, iinfo)
elif key == "l":
iinfo.show_detail = True
elif key == "d":
iinfo.display_type = "default"
elif key == "t":
iinfo.display_type = "type"
elif key == "r":
iinfo.display_type = "repr"
elif key == "s":
iinfo.display_type = "str"
elif key == "i":
iinfo.display_type = "id"
elif key == "c":
iinfo.display_type = CONFIG["custom_stringifier"]
elif key == "H":
iinfo.highlighted = not iinfo.highlighted
elif key == "@":
iinfo.repeated_at_top = not iinfo.repeated_at_top
elif key == "*":
levels = ["public", "private", "all", "public"]
iinfo.access_level = levels[levels.index(iinfo.access_level)+1]
elif key == "w":
iinfo.wrap = not iinfo.wrap
elif key == "m":
iinfo.show_methods = not iinfo.show_methods
self.update_var_view(focus_index=focus_index)
def edit_inspector_detail(w, size, key):
var, pos = self.var_list._w.get_focus()
if var is None:
return
fvi = self.get_frame_var_info(read_only=False)
iinfo = fvi.get_inspect_info(var.id_path, read_only=False)
buttons = [
("OK", True),
("Cancel", False),
]
if var.watch_expr is not None:
watch_edit = urwid.Edit([
("label", "Watch expression: ")
], var.watch_expr.expression)
id_segment = [urwid.AttrMap(watch_edit, "value"), urwid.Text("")]
buttons.extend([None, ("Delete", "del")])
title = "Watch Expression Options"
else:
id_segment = [
labelled_value("Identifier Path: ", var.id_path),
urwid.Text(""),
]
title = "Variable Inspection Options"
rb_grp_show = []
rb_show_default = urwid.RadioButton(rb_grp_show, "Default",
iinfo.display_type == "default")
rb_show_type = urwid.RadioButton(rb_grp_show, "Show type()",
iinfo.display_type == "type")
rb_show_repr = urwid.RadioButton(rb_grp_show, "Show repr()",
iinfo.display_type == "repr")
rb_show_str = urwid.RadioButton(rb_grp_show, "Show str()",
iinfo.display_type == "str")
rb_show_id = urwid.RadioButton(rb_grp_show, "Show id()",
iinfo.display_type == "id")
rb_show_custom = urwid.RadioButton(
rb_grp_show, "Show custom (set in prefs)",
iinfo.display_type == CONFIG["custom_stringifier"])
rb_grp_access = []
rb_access_public = urwid.RadioButton(rb_grp_access, "Public members",
iinfo.access_level == "public")
rb_access_private = urwid.RadioButton(
rb_grp_access, "Public and private members",
iinfo.access_level == "private")
rb_access_all = urwid.RadioButton(
rb_grp_access, "All members (including __dunder__)",
iinfo.access_level == "all")
wrap_checkbox = urwid.CheckBox("Line Wrap", iinfo.wrap)
expanded_checkbox = urwid.CheckBox("Expanded", iinfo.show_detail)
highlighted_checkbox = urwid.CheckBox("Highlighted", iinfo.highlighted)
repeated_at_top_checkbox = urwid.CheckBox(
"Repeated at top", iinfo.repeated_at_top)
show_methods_checkbox = urwid.CheckBox(
"Show methods", iinfo.show_methods)
lb = urwid.ListBox(urwid.SimpleListWalker(
id_segment
+ rb_grp_show + [urwid.Text("")]
+ rb_grp_access + [urwid.Text("")]
+ [
wrap_checkbox,
expanded_checkbox,
highlighted_checkbox,
repeated_at_top_checkbox,
show_methods_checkbox,
]))
result = self.dialog(lb, buttons, title=title)
if result is True:
iinfo.show_detail = expanded_checkbox.get_state()
iinfo.wrap = wrap_checkbox.get_state()
iinfo.highlighted = highlighted_checkbox.get_state()
iinfo.repeated_at_top = repeated_at_top_checkbox.get_state()
iinfo.show_methods = show_methods_checkbox.get_state()
if rb_show_default.get_state():
iinfo.display_type = "default"
elif rb_show_type.get_state():
iinfo.display_type = "type"
elif rb_show_repr.get_state():
iinfo.display_type = "repr"
elif rb_show_str.get_state():
iinfo.display_type = "str"
elif rb_show_id.get_state():
iinfo.display_type = "id"
elif rb_show_custom.get_state():
iinfo.display_type = CONFIG["custom_stringifier"]
if rb_access_public.get_state():
iinfo.access_level = "public"
elif rb_access_private.get_state():
iinfo.access_level = "private"
elif rb_access_all.get_state():
iinfo.access_level = "all"
if var.watch_expr is not None:
var.watch_expr.expression = watch_edit.get_edit_text()
elif result == "del":
for i, watch_expr in enumerate(fvi.watches):
if watch_expr is var.watch_expr:
del fvi.watches[i]
self.update_var_view()
def insert_watch(w, size, key):
watch_edit = urwid.Edit([
("label", "Watch expression: ")
])
if self.dialog(
urwid.ListBox(urwid.SimpleListWalker([
urwid.AttrMap(watch_edit, "value")
])),
[
("OK", True),
("Cancel", False),
], title="Add Watch Expression"):
from pudb.var_view import WatchExpression
we = WatchExpression(watch_edit.get_edit_text())
fvi = self.get_frame_var_info(read_only=False)
fvi.watches.append(we)
self.update_var_view()
self.var_list.listen("\\", change_var_state)
self.var_list.listen(" ", change_var_state)
self.var_list.listen("h", change_var_state)
self.var_list.listen("l", change_var_state)
self.var_list.listen("d", change_var_state)
self.var_list.listen("t", change_var_state)
self.var_list.listen("r", change_var_state)
self.var_list.listen("s", change_var_state)
self.var_list.listen("i", change_var_state)
self.var_list.listen("c", change_var_state)
self.var_list.listen("H", change_var_state)
self.var_list.listen("@", change_var_state)
self.var_list.listen("*", change_var_state)
self.var_list.listen("w", change_var_state)
self.var_list.listen("m", change_var_state)
self.var_list.listen("enter", change_var_state)
self.var_list.listen("e", edit_inspector_detail)
self.var_list.listen("n", insert_watch)
self.var_list.listen("insert", insert_watch)
self.var_list.listen("[", partial(change_rhs_box, "variables", 0, -1))
self.var_list.listen("]", partial(change_rhs_box, "variables", 0, 1))
# }}}
# {{{ stack listeners
def examine_frame(w, size, key):
_, pos = self.stack_list._w.get_focus()
self.debugger.set_frame_index(self.translate_ui_stack_index(pos))
self.stack_list.listen("enter", examine_frame)
def open_file_editor(file_name, line_number):
file_changed = False
try:
original_modification_time = os.path.getmtime(file_name)
self.screen.stop()
filename_edited = self.debugger.open_file_to_edit(file_name,
line_number)
self.screen.start()
new_modification_time = os.path.getmtime(file_name)
file_changed = new_modification_time - original_modification_time > 0
except Exception:
from traceback import format_exception
self.message("Exception happened when trying to edit the file:"
"\n\n%s" % ("".join(format_exception(*sys.exc_info()))),
title="File Edit Error")
return
if file_changed:
self.message("File is changed, but the execution is continued with"
" the 'old' codebase.\n"
f"Changed file: {filename_edited}\n\n"
"Please quit and restart to see changes",
title="File is changed")
def open_editor_on_stack_frame(w, size, key):
_, pos = self.stack_list._w.get_focus()
index = self.translate_ui_stack_index(pos)
curframe, line_number = self.debugger.stack[index]
file_name = curframe.f_code.co_filename
open_file_editor(file_name, line_number)
self.stack_list.listen("ctrl e", open_editor_on_stack_frame)
def move_stack_top(w, size, key):
self.debugger.set_frame_index(len(self.debugger.stack)-1)
def move_stack_up(w, size, key):
self.debugger.move_up_frame()
def move_stack_down(w, size, key):
self.debugger.move_down_frame()
self.stack_list.listen("H", move_stack_top)
self.stack_list.listen("u", move_stack_up)
self.stack_list.listen("d", move_stack_down)
self.stack_list.listen("[", partial(change_rhs_box, "stack", 1, -1))
self.stack_list.listen("]", partial(change_rhs_box, "stack", 1, 1))
# }}}
# {{{ breakpoint listeners
def save_breakpoints(w, size, key):
self.debugger.save_breakpoints()
def delete_breakpoint(w, size, key):
bp_source_identifier = \
self.source_code_provider.get_source_identifier()
if bp_source_identifier is None:
self.message(
"Cannot currently delete a breakpoint here--"
"source code does not correspond to a file location. "
"(perhaps this is generated code)")
bp_list = self._get_bp_list()
if bp_list:
_, pos = self.bp_list._w.get_focus()
bp = bp_list[pos]
if bp_source_identifier == bp.file and bp.line-1 < len(self.source):
self.source[bp.line-1].set_breakpoint(False)
err = self.debugger.clear_break(bp.file, bp.line)
if err:
self.message("Error clearing breakpoint:\n" + err)
else:
self.update_breakpoints()
def enable_disable_breakpoint(w, size, key):
bp_entry, pos = self.bp_list._w.get_focus()
if bp_entry is None:
return
bp = self._get_bp_list()[pos]
bp.enabled = not bp.enabled
sline = self.source[bp.line-1]
sline.set_breakpoint(bp.enabled)
self.update_breakpoints()
def examine_breakpoint(w, size, key):
bp_entry, pos = self.bp_list._w.get_focus()
if bp_entry is None:
return
bp = self._get_bp_list()[pos]
if bp.cond is None:
cond = ""
else:
cond = str(bp.cond)
enabled_checkbox = urwid.CheckBox(
"Enabled", bp.enabled)
cond_edit = urwid.Edit([
("label", "Condition: ")
], cond)
ign_count_edit = urwid.IntEdit([
("label", "Ignore the next N times: ")
], bp.ignore)
lb = urwid.ListBox(urwid.SimpleListWalker([
labelled_value("File: ", bp.file),
labelled_value("Line: ", bp.line),
labelled_value("Hits: ", bp.hits),
urwid.Text(""),
enabled_checkbox,
urwid.AttrMap(cond_edit, "value", "value"),
urwid.AttrMap(ign_count_edit, "value", "value"),
]))
result = self.dialog(lb, [
("OK", True),
("Cancel", False),
None,
("Delete", "del"),
("Location", "loc"),
], title="Edit Breakpoint")
if result is True:
bp.enabled = enabled_checkbox.get_state()
bp.ignore = int(ign_count_edit.value())
cond = cond_edit.get_edit_text()
if cond:
bp.cond = cond
else:
bp.cond = None
elif result == "loc":
self.show_line(bp.line,
FileSourceCodeProvider(self.debugger, bp.file))
self.columns.set_focus(0)
elif result == "del":
bp_source_identifier = \
self.source_code_provider.get_source_identifier()
if bp_source_identifier is None:
self.message(
"Cannot currently delete a breakpoint here--"
"source code does not correspond to a file location. "
"(perhaps this is generated code)")
if bp_source_identifier == bp.file:
self.source[bp.line-1].set_breakpoint(False)
err = self.debugger.clear_break(bp.file, bp.line)
if err:
self.message("Error clearing breakpoint:\n" + err)
else:
self.update_breakpoints()
def show_breakpoint(w, size, key):
bp_entry, pos = self.bp_list._w.get_focus()
if bp_entry is not None:
bp = self._get_bp_list()[pos]
self.show_line(bp.line,
FileSourceCodeProvider(self.debugger, bp.file))
self.bp_list.listen("enter", show_breakpoint)
self.bp_list.listen("d", delete_breakpoint)
self.bp_list.listen("s", save_breakpoints)
self.bp_list.listen("e", examine_breakpoint)
self.bp_list.listen("b", enable_disable_breakpoint)
self.bp_list.listen("H", move_stack_top)
self.bp_list.listen("[", partial(change_rhs_box, "breakpoints", 2, -1))
self.bp_list.listen("]", partial(change_rhs_box, "breakpoints", 2, 1))
# }}}
# {{{ source listeners
def end():
self.debugger.save_breakpoints()
self.quit_event_loop = True
def next_line(w, size, key):
if self.debugger.post_mortem:
self.message("Post-mortem mode: Can't modify state.")
else:
self.debugger.set_next(self.debugger.curframe)
end()
def step(w, size, key):
if self.debugger.post_mortem:
self.message("Post-mortem mode: Can't modify state.")
else:
self.debugger.set_step()
end()
def finish(w, size, key):
if self.debugger.post_mortem:
self.message("Post-mortem mode: Can't modify state.")
else:
self.debugger.set_return(self.debugger.curframe)
end()
def cont(w, size, key):
if self.debugger.post_mortem:
self.message("Post-mortem mode: Can't modify state.")
else:
self.debugger.set_continue()
end()
def run_to_cursor(w, size, key):
if self.debugger.post_mortem:
self.message("Post-mortem mode: Can't modify state.")
else:
sline, pos = self.source.get_focus()
lineno = pos+1
bp_source_identifier = \
self.source_code_provider.get_source_identifier()
if bp_source_identifier is None:
self.message(
"Cannot currently set a breakpoint here--"
"source code does not correspond to a file location. "
"(perhaps this is generated code)")
from pudb.lowlevel import get_breakpoint_invalid_reason
invalid_reason = get_breakpoint_invalid_reason(
bp_source_identifier, lineno)
if invalid_reason is not None:
self.message(
"Cannot run to the line you indicated, "
"for the following reason:\n\n"
+ invalid_reason)
else:
err = self.debugger.set_break(
bp_source_identifier, pos+1, temporary=True)
if err:
self.message("Error dealing with breakpoint:\n" + err)
self.debugger.set_continue()
end()
def go_to_line(w, size, key):
_, line = self.source.get_focus()
lineno_edit = urwid.IntEdit([
("label", "Go to Line :")
], None)
if self.dialog(
urwid.ListBox(urwid.SimpleListWalker([
labelled_value("File :",
self.source_code_provider.identifier()),
labelled_value("Current Line :", line+1),
urwid.AttrMap(lineno_edit, "value")
])),
[
("OK", True),
("Cancel", False),
], title="Go to Line Number"):
lineno = min(max(0, int(lineno_edit.value())-1), len(self.source)-1)
self.source.set_focus(lineno)
def scroll_left(w, size, key):
self.source_hscroll_start = max(
0,
self.source_hscroll_start - 4)
for sl in self.source:
sl._invalidate()
def scroll_right(w, size, key):
self.source_hscroll_start += 4
for sl in self.source:
sl._invalidate()
def search(w, size, key):
self.search_controller.open_search_ui()
def search_next(w, size, key):
self.search_controller.perform_search(dir=1, update_search_start=True)
def search_previous(w, size, key):
self.search_controller.perform_search(dir=-1, update_search_start=True)
def toggle_breakpoint(w, size, key):
bp_source_identifier = \
self.source_code_provider.get_source_identifier()
if bp_source_identifier:
sline, pos = self.source.get_focus()
lineno = pos+1
existing_breaks = self.debugger.get_breaks(
bp_source_identifier, lineno)
if existing_breaks:
err = None
for bp in existing_breaks:
if not bp.enabled:
bp.enable()
sline.set_breakpoint(True)
# Unsure about this. Are multiple breakpoints even
# possible?
break
else:
err = self.debugger.clear_break(bp_source_identifier, lineno)
sline.set_breakpoint(False)
else:
file_lineno = (bp_source_identifier, lineno)
if file_lineno in self.debugger.set_traces:
self.debugger.set_traces[file_lineno] = \
not self.debugger.set_traces[file_lineno]
sline.set_breakpoint(self.debugger.set_traces[file_lineno])
return
from pudb.lowlevel import get_breakpoint_invalid_reason
invalid_reason = get_breakpoint_invalid_reason(
bp_source_identifier, pos+1)
if invalid_reason is not None:
do_set = not self.dialog(
urwid.ListBox(
urwid.SimpleListWalker([
urwid.Text(
"The breakpoint you just set may be "
"invalid, for the following reason:\n\n"
+ invalid_reason),
])), [
("Cancel", True),
("Set Anyway", False),
],
title="Possibly Invalid Breakpoint",
focus_buttons=True)
else:
do_set = True
if do_set:
err = self.debugger.set_break(bp_source_identifier, pos+1)
sline.set_breakpoint(True)
else:
err = None
if err:
self.message("Error dealing with breakpoint:\n" + err)
self.update_breakpoints()
else:
self.message(
"Cannot currently set a breakpoint here--"
"source code does not correspond to a file location. "
"(perhaps this is generated code)")
def pick_module(w, size, key):
from os.path import splitext
import sys
def mod_exists(mod):
if not hasattr(mod, "__file__"):
return False
if mod.__file__ is None:
return False
filename = mod.__file__
base, ext = splitext(filename)
ext = ext.lower()
from os.path import exists
if ext == ".pyc":
return exists(base+".py")
else:
return ext == ".py"
new_mod_text = SelectableText("-- update me --")
new_mod_entry = urwid.AttrMap(new_mod_text,
None, "focused selectable")
def build_filtered_mod_list(filt_string=""):
modules = sorted(name
# mod_exists may change the size of sys.modules,
# causing this to crash. Copy to a list.
for name, mod in list(sys.modules.items())
if mod_exists(mod))
result = [urwid.AttrMap(SelectableText(mod),
None, "focused selectable")
for mod in modules if filt_string in mod]
new_mod_text.set_text("<<< IMPORT MODULE '%s' >>>" % filt_string)
result.append(new_mod_entry)
return result
def show_mod(mod):
filename = self.debugger.canonic(mod.__file__)
base, ext = splitext(filename)
if ext == ".pyc":
ext = ".py"
filename = base+".py"
self.set_source_code_provider(
FileSourceCodeProvider(self.debugger, filename))
self.source_list.set_focus(0)
class FilterEdit(urwid.Edit):
def keypress(self, size, key):
result = urwid.Edit.keypress(self, size, key)
if result is None:
mod_list[:] = build_filtered_mod_list(
self.get_edit_text())
return result
filt_edit = FilterEdit([("label", "Filter: ")],
self.last_module_filter)
mod_list = urwid.SimpleListWalker(
build_filtered_mod_list(filt_edit.get_edit_text()))
lb = urwid.ListBox(mod_list)
w = urwid.Pile([
("flow", urwid.AttrMap(filt_edit, "value")),
("fixed", 1, urwid.SolidFill()),
urwid.AttrMap(lb, "selectable")])
while True:
result = self.dialog(w, [
("OK", True),
("Cancel", False),
("Reload", "reload"),
], title="Pick Module")
self.last_module_filter = filt_edit.get_edit_text()
if result is True:
widget, pos = lb.get_focus()
if widget is new_mod_entry:
new_mod_name = filt_edit.get_edit_text()
try:
__import__(str(new_mod_name))
except Exception:
from traceback import format_exception
self.message(
"Could not import module '{}':\n\n{}".format(
new_mod_name, "".join(
format_exception(*sys.exc_info()))),
title="Import Error")
else:
show_mod(__import__(str(new_mod_name)))
break
else:
show_mod(sys.modules[widget.base_widget.get_text()[0]])
break
elif result is False:
break
elif result == "reload":
widget, pos = lb.get_focus()
if widget is not new_mod_entry:
mod_name = widget.base_widget.get_text()[0]
mod = sys.modules[mod_name]
import importlib
importlib.reload(mod)
self.message("'%s' was successfully reloaded." % mod_name)
if self.source_code_provider is not None:
self.source_code_provider.clear_cache()
self.set_source_code_provider(self.source_code_provider,
force_update=True)
_, pos = self.stack_list._w.get_focus()
self.debugger.set_frame_index(
self.translate_ui_stack_index(pos))
def helpmain(w, size, key):
help(HELP_HEADER + HELP_MAIN + HELP_SIDE + HELP_LICENSE)
self.source_sigwrap.listen("n", next_line)
self.source_sigwrap.listen("s", step)
self.source_sigwrap.listen("f", finish)
self.source_sigwrap.listen("r", finish)
self.source_sigwrap.listen("c", cont)
self.source_sigwrap.listen("t", run_to_cursor)
self.source_sigwrap.listen("L", go_to_line)
self.source_sigwrap.listen("/", search)
self.source_sigwrap.listen(",", search_previous)
self.source_sigwrap.listen(".", search_next)
self.source_sigwrap.listen("b", toggle_breakpoint)
self.source_sigwrap.listen("m", pick_module)
self.source_sigwrap.listen("H", move_stack_top)
self.source_sigwrap.listen("u", move_stack_up)
self.source_sigwrap.listen("d", move_stack_down)
# left/right scrolling have to be handled specially, normal vi keys
# don't cut it
self.source_sigwrap.listen("h", scroll_left)
self.source_sigwrap.listen("l", scroll_right)
add_vi_nav_keys(self.source_sigwrap)
add_help_keys(self.source_sigwrap, helpmain)
# }}}
# {{{ command line listeners
def cmdline_get_namespace():
curframe = self.debugger.curframe
from pudb.shell import SetPropagatingDict
return SetPropagatingDict(
[curframe.f_locals, curframe.f_globals],
curframe.f_locals)
def cmdline_tab_complete(w, size, key):
try:
from jedi import Interpreter
except ImportError:
self.add_cmdline_content(
"Tab completion requires jedi to be installed. ",
"command line error")
return
import jedi
from distutils.version import LooseVersion
if LooseVersion(jedi.__version__) < LooseVersion("0.16.0"):
self.add_cmdline_content(
"jedi 0.16.0 is required for Tab completion",
"command line error")
text = self.cmdline_edit.edit_text
pos = self.cmdline_edit.edit_pos
chopped_text = text[:pos]
suffix = text[pos:]
try:
completions = Interpreter(
chopped_text,
[cmdline_get_namespace()]).complete()
except Exception as e:
# Jedi sometimes produces errors. Ignore them.
self.add_cmdline_content(
"Could not tab complete (Jedi error: '%s')" % e,
"command line error")
return
full_completions = [i.name_with_symbols for i in completions]
chopped_completions = [i.complete for i in completions]
def common_prefix(a, b):
for i, (a_i, b_i) in enumerate(zip(a, b)):
if a_i != b_i:
return a[:i]
return a[:max(len(a), len(b))]
common_compl_prefix = None
for completion in chopped_completions:
if common_compl_prefix is None:
common_compl_prefix = completion
else:
common_compl_prefix = common_prefix(
common_compl_prefix, completion)
completed_chopped_text = common_compl_prefix
if completed_chopped_text is None:
return
if (
len(completed_chopped_text) == 0
and len(completions) > 1):
self.add_cmdline_content(
" ".join(full_completions),
"command line output")
return
self.cmdline_edit.edit_text = \
chopped_text+completed_chopped_text+suffix
self.cmdline_edit.edit_pos = (
len(chopped_text)
+ len(completed_chopped_text))
def cmdline_append_newline(w, size, key):
self.cmdline_edit.insert_text("\n")
def cmdline_exec(w, size, key):
cmd = self.cmdline_edit.get_edit_text()
if not cmd:
# blank command -> refuse service
return
self.add_cmdline_content(">>> " + cmd, "command line input")
if not self.cmdline_history or cmd != self.cmdline_history[-1]:
self.cmdline_history.append(cmd)
self.cmdline_history_position = -1
prev_sys_stdin = sys.stdin
prev_sys_stdout = sys.stdout
prev_sys_stderr = sys.stderr
from io import StringIO
sys.stdin = None
sys.stderr = sys.stdout = StringIO()
try:
eval(compile(cmd, "<pudb command line>", "single"),
cmdline_get_namespace())
except Exception:
tp, val, tb = sys.exc_info()
import traceback
tblist = traceback.extract_tb(tb)
del tblist[:1]
tb_lines = traceback.format_list(tblist)
if tb_lines:
tb_lines.insert(0, "Traceback (most recent call last):\n")
tb_lines[len(tb_lines):] = traceback.format_exception_only(tp, val)
self.add_cmdline_content("".join(tb_lines), "command line error")
else:
self.cmdline_edit.set_edit_text("")
finally:
if sys.stdout.getvalue():
self.add_cmdline_content(sys.stdout.getvalue(),
"command line output")
sys.stdin = prev_sys_stdin
sys.stdout = prev_sys_stdout
sys.stderr = prev_sys_stderr
def cmdline_history_browse(direction):
if self.cmdline_history_position == -1:
self.cmdline_history_position = len(self.cmdline_history)
self.cmdline_history_position += direction
if 0 <= self.cmdline_history_position < len(self.cmdline_history):
self.cmdline_edit.edit_text = \
self.cmdline_history[self.cmdline_history_position]
else:
self.cmdline_history_position = -1
self.cmdline_edit.edit_text = ""
self.cmdline_edit.edit_pos = len(self.cmdline_edit.edit_text)
def cmdline_history_prev(w, size, key):
cmdline_history_browse(-1)
def cmdline_history_next(w, size, key):
cmdline_history_browse(1)
def cmdline_start_of_line(w, size, key):
self.cmdline_edit.edit_pos = 0
def cmdline_end_of_line(w, size, key):
self.cmdline_edit.edit_pos = len(self.cmdline_edit.edit_text)
def cmdline_del_word(w, size, key):
pos = self.cmdline_edit.edit_pos
before, after = (
self.cmdline_edit.edit_text[:pos],
self.cmdline_edit.edit_text[pos:])
before = before[::-1]
before = before.lstrip()
i = 0
while i < len(before):
if not before[i].isspace():
i += 1
else:
break
self.cmdline_edit.edit_text = before[i:][::-1] + after
self.cmdline_edit.edit_post = len(before[i:])
def cmdline_del_to_start_of_line(w, size, key):
pos = self.cmdline_edit.edit_pos
self.cmdline_edit.edit_text = self.cmdline_edit.edit_text[pos:]
self.cmdline_edit.edit_pos = 0
def toggle_cmdline_focus(w, size, key):
self.columns.set_focus(self.lhs_col)
if self.lhs_col.get_focus() is self.cmdline_sigwrap:
if CONFIG["hide_cmdline_win"]:
self.set_cmdline_state(False)
self.lhs_col.set_focus(self.search_controller.search_AttrMap
if self.search_controller.search_box else
self.source_attr)
else:
if CONFIG["hide_cmdline_win"]:
self.set_cmdline_state(True)
self.cmdline_pile.set_focus(self.cmdline_edit_bar)
self.lhs_col.set_focus(self.cmdline_sigwrap)
self.cmdline_edit_sigwrap.listen("tab", cmdline_tab_complete)
self.cmdline_edit_sigwrap.listen("ctrl v", cmdline_append_newline)
self.cmdline_edit_sigwrap.listen("enter", cmdline_exec)
self.cmdline_edit_sigwrap.listen("ctrl n", cmdline_history_next)
self.cmdline_edit_sigwrap.listen("ctrl p", cmdline_history_prev)
self.cmdline_edit_sigwrap.listen("esc", toggle_cmdline_focus)
self.cmdline_edit_sigwrap.listen("ctrl d", toggle_cmdline_focus)
self.cmdline_edit_sigwrap.listen("ctrl a", cmdline_start_of_line)
self.cmdline_edit_sigwrap.listen("ctrl e", cmdline_end_of_line)
self.cmdline_edit_sigwrap.listen("ctrl w", cmdline_del_word)
self.cmdline_edit_sigwrap.listen("ctrl u", cmdline_del_to_start_of_line)
self.top.listen("ctrl x", toggle_cmdline_focus)
# {{{ command line sizing
def set_cmdline_default_size(weight):
self.cmdline_weight = weight
self.set_cmdline_size()
def max_cmdline(w, size, key):
set_cmdline_default_size(5)
def min_cmdline(w, size, key):
set_cmdline_default_size(1/2)
def grow_cmdline(w, size, key):
weight = self.cmdline_weight
if weight < 5:
weight *= 1.25
set_cmdline_default_size(weight)
def shrink_cmdline(w, size, key):
weight = self.cmdline_weight
if weight > 1/2:
weight /= 1.25
set_cmdline_default_size(weight)
self.cmdline_sigwrap.listen("=", max_cmdline)
self.cmdline_sigwrap.listen("+", grow_cmdline)
self.cmdline_sigwrap.listen("_", min_cmdline)
self.cmdline_sigwrap.listen("-", shrink_cmdline)
# }}}
# }}}
# {{{ sidebar sizing
def max_sidebar(w, size, key):
from pudb.settings import save_config
weight = 5
CONFIG["sidebar_width"] = weight
save_config(CONFIG)
self.columns.column_types[1] = "weight", weight
self.columns._invalidate()
def min_sidebar(w, size, key):
from pudb.settings import save_config
weight = 1/5
CONFIG["sidebar_width"] = weight
save_config(CONFIG)
self.columns.column_types[1] = "weight", weight
self.columns._invalidate()
def grow_sidebar(w, size, key):
from pudb.settings import save_config
weight = self.columns.column_types[1][1]
if weight < 5:
weight *= 1.25
CONFIG["sidebar_width"] = weight
save_config(CONFIG)
self.columns.column_types[1] = "weight", weight
self.columns._invalidate()
def shrink_sidebar(w, size, key):
from pudb.settings import save_config
weight = self.columns.column_types[1][1]
if weight > 1/5:
weight /= 1.25
CONFIG["sidebar_width"] = weight
save_config(CONFIG)
self.columns.column_types[1] = "weight", weight
self.columns._invalidate()
self.rhs_col_sigwrap.listen("=", max_sidebar)
self.rhs_col_sigwrap.listen("+", grow_sidebar)
self.rhs_col_sigwrap.listen("_", min_sidebar)
self.rhs_col_sigwrap.listen("-", shrink_sidebar)
# }}}
# {{{ top-level listeners
def show_output(w, size, key):
self.screen.stop()
input("Hit Enter to return:")
self.screen.start()
def reload_breakpoints_and_redisplay():
reload_breakpoints()
curr_line = self.current_line
self.set_source_code_provider(self.source_code_provider,
force_update=True)
if curr_line is not None:
self.current_line = self.source[int(curr_line.line_nr)-1]
self.current_line.set_current(True)
def reload_breakpoints():
self.debugger.clear_all_breaks()
from pudb.settings import load_breakpoints
for bpoint_descr in load_breakpoints():
dbg.set_break(*bpoint_descr)
self.update_breakpoints()
def show_traceback(w, size, key):
if self.current_exc_tuple is not None:
from traceback import format_exception
result = self.dialog(
urwid.ListBox(urwid.SimpleListWalker([urwid.Text(
"".join(format_exception(*self.current_exc_tuple)))])),
[
("Close", "close"),
("Location", "location")
],
title="Exception Viewer",
focus_buttons=True,
bind_enter_esc=False)
if result == "location":
self.debugger.set_frame_index(len(self.debugger.stack)-1)
else:
self.message("No exception available.")
def run_external_cmdline(w, size, key):
self.screen.stop()
curframe = self.debugger.curframe
import pudb.shell as shell
if CONFIG["shell"] == "ipython" and shell.have_ipython():
runner = shell.run_ipython_shell
elif CONFIG["shell"] == "ipython_kernel" and shell.have_ipython():
runner = shell.run_ipython_kernel
elif CONFIG["shell"] == "bpython" and shell.HAVE_BPYTHON:
runner = shell.run_bpython_shell
elif CONFIG["shell"] == "ptpython" and shell.HAVE_PTPYTHON:
runner = shell.run_ptpython_shell
elif CONFIG["shell"] == "ptipython" and shell.HAVE_PTIPYTHON:
runner = shell.run_ptipython_shell
elif CONFIG["shell"] == "classic":
runner = shell.run_classic_shell
else:
try:
if not shell.custom_shell_dict: # Only execfile once
from os.path import expanduser
cshell_fname = expanduser(CONFIG["shell"])
with open(cshell_fname) as inf:
exec(compile(inf.read(), cshell_fname, "exec"),
shell.custom_shell_dict,
shell.custom_shell_dict)
except Exception:
print("Error when importing custom shell:")
from traceback import print_exc
print_exc()
print("Falling back to classic shell")
runner = shell.run_classic_shell
else:
if "pudb_shell" not in shell.custom_shell_dict:
print("%s does not contain a function named pudb_shell at "
"the module level." % CONFIG["shell"])
print("Falling back to classic shell")
runner = shell.run_classic_shell
else:
runner = shell.custom_shell_dict["pudb_shell"]
runner(curframe.f_globals, curframe.f_locals)
self.screen.start()
self.update_var_view()
def run_cmdline(w, size, key):
if CONFIG["shell"] == "internal":
return toggle_cmdline_focus(w, size, key)
else:
return run_external_cmdline(w, size, key)
def focus_code(w, size, key):
self.columns.set_focus(self.lhs_col)
self.lhs_col.set_focus(self.source_attr)
class RHColumnFocuser:
def __init__(self, idx):
self.idx = idx
def __call__(subself, w, size, key): # noqa # pylint: disable=no-self-argument
self.columns.set_focus(self.rhs_col_sigwrap)
self.rhs_col.set_focus(self.rhs_col.widget_list[subself.idx])
def quit(w, size, key):
self.debugger.set_quit()
end()
def do_edit_config(w, size, key):
self.run_edit_config()
def redraw_screen(w, size, key):
self.screen.clear()
def help(pages):
self.message(pages, title="PuDB - The Python Urwid Debugger")
def edit_current_frame(w, size, key):
_, pos = self.source.get_focus()
source_identifier = \
self.source_code_provider.get_source_identifier()
if source_identifier is None:
self.message(
"Cannot edit the current file--"
"source code does not correspond to a file location. "
"(perhaps this is generated code)")
open_file_editor(source_identifier, pos+1)
self.top.listen("o", show_output)
self.top.listen("ctrl r",
lambda w, size, key: reload_breakpoints_and_redisplay())
self.top.listen("!", run_cmdline)
self.top.listen("e", show_traceback)
self.top.listen("C", focus_code)
self.top.listen("V", RHColumnFocuser(0))
self.top.listen("S", RHColumnFocuser(1))
self.top.listen("B", RHColumnFocuser(2))
self.top.listen("q", quit)
self.top.listen("ctrl p", do_edit_config)
self.top.listen("ctrl l", redraw_screen)
self.top.listen("ctrl e", edit_current_frame)
# }}}
# {{{ setup
want_curses_display = (
CONFIG["display"] == "curses"
or (
CONFIG["display"] == "auto"
and not (
os.environ.get("TERM", "").startswith("xterm")
or os.environ.get("TERM", "").startswith("rxvt")
)))
if (want_curses_display
and not (stdin is not None or stdout is not None)
and CursesScreen is not None):
self.screen = ThreadsafeCursesScreen()
else:
screen_kwargs = {}
if stdin is not None:
screen_kwargs["input"] = stdin
if stdout is not None:
screen_kwargs["output"] = stdout
if term_size is not None:
screen_kwargs["term_size"] = term_size
if screen_kwargs:
self.screen = ThreadsafeFixedSizeRawScreen(**screen_kwargs)
else:
self.screen = ThreadsafeRawScreen()
del want_curses_display
if curses:
try:
curses.setupterm()
except Exception:
# Something went wrong--oh well. Nobody will die if their
# 256 color support breaks. Just carry on without it.
# https://github.com/inducer/pudb/issues/78
pass
else:
color_support = curses.tigetnum("colors")
if color_support == 256 and isinstance(self.screen, RawScreen):
self.screen.set_terminal_properties(256)
self.setup_palette(self.screen)
self.show_count = 0
self.source_code_provider = None
self.current_line = None
self.quit_event_loop = False
# }}}
# }}}
# {{{ UI helpers
def add_cmdline_content(self, s, attr):
s = s.rstrip("\n")
from pudb.ui_tools import SelectableText
self.cmdline_contents.append(
urwid.AttrMap(SelectableText(s), attr, "focused "+attr))
# scroll to end of last entry
self.cmdline_list.set_focus_valign("bottom")
self.cmdline_list.set_focus(len(self.cmdline_contents) - 1,
coming_from="above")
# Force the commandline to be visible
self.set_cmdline_state(True)
def reset_cmdline_size(self):
self.lhs_col.item_types[-1] = "weight", \
self.cmdline_weight if self.cmdline_on else 0
def set_cmdline_size(self, weight=None):
if weight is None:
weight = self.cmdline_weight
self.lhs_col.item_types[-1] = "weight", weight
self.lhs_col._invalidate()
def set_cmdline_state(self, state_on):
if state_on != self.cmdline_on:
self.cmdline_on = state_on
self.set_cmdline_size(None if state_on else 0)
def translate_ui_stack_index(self, index):
# note: self-inverse
if CONFIG["current_stack_frame"] == "top":
return len(self.debugger.stack)-1-index
elif CONFIG["current_stack_frame"] == "bottom":
return index
else:
raise ValueError("invalid value for 'current_stack_frame' pref")
def message(self, msg, title="Message", **kwargs):
self.call_with_ui(self.dialog,
urwid.ListBox(urwid.SimpleListWalker([urwid.Text(msg)])),
[("OK", True)], title=title, **kwargs)
def run_edit_config(self):
from pudb.settings import edit_config, save_config
edit_config(self, CONFIG)
save_config(CONFIG)
def dialog(self, content, buttons_and_results,
title=None, bind_enter_esc=True, focus_buttons=False,
extra_bindings=[]):
class ResultSetter:
def __init__(subself, res): # noqa: N805, E501 # pylint: disable=no-self-argument
subself.res = res
def __call__(subself, btn): # noqa: N805, E501 # pylint: disable=no-self-argument
self.quit_event_loop = [subself.res]
Attr = urwid.AttrMap # noqa
if bind_enter_esc:
content = SignalWrap(content)
def enter(w, size, key):
self.quit_event_loop = [True]
def esc(w, size, key):
self.quit_event_loop = [False]
content.listen("enter", enter)
content.listen("esc", esc)
button_widgets = []
for btn_descr in buttons_and_results:
if btn_descr is None:
button_widgets.append(urwid.Text(""))
else:
btn_text, btn_result = btn_descr
button_widgets.append(
Attr(urwid.Button(btn_text, ResultSetter(btn_result)),
"button", "focused button"))
w = urwid.Columns([
content,
("fixed", 15, urwid.ListBox(urwid.SimpleListWalker(button_widgets))),
], dividechars=1)
if focus_buttons:
w.set_focus_column(1)
if title is not None:
w = urwid.Pile([
("flow", urwid.AttrMap(
urwid.Text(title, align="center"),
"dialog title")),
("fixed", 1, urwid.SolidFill()),
w])
class ResultSettingEventHandler:
def __init__(subself, res): # noqa: N805, E501 # pylint: disable=no-self-argument
subself.res = res
def __call__(subself, w, size, key): # noqa: N805, E501 # pylint: disable=no-self-argument
self.quit_event_loop = [subself.res]
w = SignalWrap(w)
for key, binding in extra_bindings:
if isinstance(binding, str):
w.listen(key, ResultSettingEventHandler(binding))
else:
w.listen(key, binding)
w = urwid.LineBox(w)
w = urwid.Overlay(w, self.top,
align="center",
valign="middle",
width=("relative", 75),
height=("relative", 75),
)
w = Attr(w, "background")
return self.event_loop(w)[0]
@staticmethod
def setup_palette(screen):
may_use_fancy_formats = not hasattr(urwid.escape, "_fg_attr_xterm")
from pudb.theme import get_palette
screen.register_palette(
get_palette(may_use_fancy_formats, CONFIG["theme"]))
def show_exception_dialog(self, exc_tuple):
from traceback import format_exception
desc = (
"The program has terminated abnormally because of an exception.\n\n"
"A full traceback is below. You may recall this traceback at any "
"time using the 'e' key. The debugger has entered post-mortem mode "
"and will prevent further state changes."
)
tb_txt = "".join(format_exception(*exc_tuple))
self._show_exception_dialog(
description=desc,
error_info=tb_txt,
title="Program Terminated for Uncaught Exception",
exit_loop_on_ok=True,
)
def show_internal_exc_dlg(self, exc_tuple):
try:
self._show_internal_exc_dlg(exc_tuple)
except Exception:
ui_log.exception("Error while showing error dialog")
def _show_internal_exc_dlg(self, exc_tuple):
from traceback import format_exception
from pudb import VERSION
desc = (
"Pudb has encountered and safely caught an internal exception.\n\n"
"The full traceback and some other information can be found "
"below. Please report this information, along with details on "
"what you were doing at the time the exception occurred, at: "
"https://github.com/inducer/pudb/issues"
)
error_info = (
"python version: {python}\n"
"pudb version: {pudb}\n"
"urwid version: {urwid}\n"
"{tb}\n"
).format(
python=sys.version.replace("\n", " "),
pudb=VERSION,
urwid=".".join(map(str, urwid.version.VERSION)),
tb="".join(format_exception(*exc_tuple))
)
self._show_exception_dialog(
description=desc,
error_info=error_info,
title="Pudb Internal Exception Encountered",
)
def _show_exception_dialog(self, description, error_info, title,
exit_loop_on_ok=False):
res = self.dialog(
urwid.ListBox(urwid.SimpleListWalker([urwid.Text(
"\n\n".join([description, error_info])
)])),
title=title,
buttons_and_results=[
("OK", exit_loop_on_ok),
("Save traceback", "save"),
],
)
if res == "save":
self._save_traceback(error_info)
def _save_traceback(self, error_info):
try:
from os.path import exists
filename = next(
fname for n in count()
for fname in ["traceback-%d.txt" % n if n else "traceback.txt"]
if not exists(fname)
)
with open(filename, "w") as outf:
outf.write(error_info)
self.message("Traceback saved as %s." % filename, title="Success")
except Exception:
from traceback import format_exception
io_tb_txt = "".join(format_exception(*sys.exc_info()))
self.message(
"An error occurred while trying to write "
"the traceback:\n\n" + io_tb_txt,
title="I/O error")
# }}}
# {{{ UI enter/exit
def show(self):
if self.show_count == 0:
self.screen.start()
self.show_count += 1
def hide(self):
self.show_count -= 1
if self.show_count == 0:
self.screen.stop()
def call_with_ui(self, f, *args, **kwargs):
self.show()
try:
return f(*args, **kwargs)
finally:
self.hide()
# }}}
# {{{ interaction
def event_loop(self, toplevel=None):
prev_quit_loop = self.quit_event_loop
try:
import pygments # noqa
except ImportError:
if not hasattr(self, "pygments_message_shown"):
self.pygments_message_shown = True
self.message("Package 'pygments' not found. "
"Syntax highlighting disabled.")
WELCOME_LEVEL = "e039" # noqa
if CONFIG["seen_welcome"] < WELCOME_LEVEL:
CONFIG["seen_welcome"] = WELCOME_LEVEL
from pudb import VERSION
self.message("Welcome to PudB %s!\n\n"
"PuDB is a full-screen, console-based visual debugger for "
"Python. Its goal is to provide all the niceties of modern "
"GUI-based debuggers in a more lightweight and "
"keyboard-friendly package. "
"PuDB allows you to debug code right where you write and test "
"it--in a terminal. If you've worked with the excellent "
"(but nowadays ancient) DOS-based Turbo Pascal or C tools, "
"PuDB's UI might look familiar.\n\n"
"If you're new here, welcome! The help screen "
"(invoked by hitting '?' after this message) should get you "
"on your way.\n"
"\nChanges in version 2021.1:\n\n"
"- Add shortcut to edit files in source and stack view "
"(Gábor Vecsei)\n"
"- Major improvements to the variable view "
"(Michael van der Kamp)\n"
"- Better internal error reporting (Michael van der Kamp)\n"
"\nChanges in version 2020.1:\n\n"
"- Add vi keys for the sidebar (Asbjørn Apeland)\n"
"- Add -m command line switch (Elias Dorneles)\n"
"- Debug forked processes (Jonathan Striebel)\n"
"- Robustness and logging for internal errors "
"(Michael Vanderkamp)\n"
"- 'Reverse' remote debugging (jen6)\n"
"\nChanges in version 2019.2:\n\n"
"- Auto-hide the command line (Mark Blakeney)\n"
"- Improve help and add jump to breakpoint (Mark Blakeney)\n"
"- Drop Py2.6 support\n"
"- Show callable attributes in var view\n"
"- Allow scrolling sidebar with j/k\n"
"- Fix setting breakpoints in Py3.8 (Aaron Meurer)\n"
"\nChanges in version 2019.1:\n\n"
"- Allow 'space' as a key to expand variables (Enrico Troeger)\n"
"- Have a persistent setting on variable visibility \n"
" (Enrico Troeger)\n"
"- Enable/partially automate opening the debugger in another \n"
" terminal (Anton Barkovsky)\n"
"- Make sidebar scrollable with j/k (Clayton Craft)\n"
"- Bug fixes.\n"
"\nChanges in version 2018.1:\n\n"
"- Bug fixes.\n"
"\nChanges in version 2017.1.4:\n\n"
"- Bug fixes.\n"
"\nChanges in version 2017.1.3:\n\n"
"- Add handling of safely_stringify_for_pudb to allow custom \n"
" per-type stringification.\n"
"- Add support for custom shells.\n"
"- Better support for 2-wide characters in the var view.\n"
"- Bug fixes.\n"
"\nChanges in version 2017.1.2:\n\n"
"- Bug fixes.\n"
"\nChanges in version 2017.1.1:\n\n"
"- IMPORTANT: 2017.1 and possibly earlier versions had a \n"
" bug with exponential growth of shell history for the \n"
" 'classic' shell, which (among other problems) could lead\n"
" to slow startup of the classic shell. Check the file\n\n"
" ~/.config/pudb/shell-history\n\n"
" for size (and useful content) and delete/trim as needed.\n"
"\nChanges in version 2017.1:\n\n"
"- Many, many bug fixes (thank you to all who contributed!)\n"
"\nChanges in version 2016.2:\n\n"
"- UI improvements for disabled breakpoints.\n"
"- Bug fixes.\n"
"\nChanges in version 2016.1:\n\n"
"- Fix module browser on Py3.\n"
"\nChanges in version 2015.4:\n\n"
"- Support for (somewhat rudimentary) remote debugging\n"
" through a telnet connection.\n"
"- Fix debugging of generated code in Python 3.\n"
"\nChanges in version 2015.3:\n\n"
"- Disable set_trace lines from the UI (Aaron Meurer)\n"
"- Better control over attribute visibility (Ned Batchelder)\n"
"\nChanges in version 2015.2:\n\n"
"- ptpython support (P. Varet)\n"
"- Improved rxvt support (Louper Rouch)\n"
"- More keyboard shortcuts in the command line"
"(Alex Sheluchin)\n"
"\nChanges in version 2015.1:\n\n"
"- Add solarized theme (Rinat Shigapov)\n"
"- More keyboard shortcuts in the command line"
"(Alexander Corwin)\n"
"\nChanges in version 2014.1:\n\n"
"- Make prompt-on-quit optional (Mike Burr)\n"
"- Make tab completion in the built-in shell saner\n"
"- Fix handling of unicode source\n"
" (reported by Morten Nielsen and Buck Golemon)\n"
"\nChanges in version 2013.5.1:\n\n"
"- Fix loading of saved breakpoint conditions "
"(Antoine Dechaume)\n"
"- Fixes for built-in command line\n"
"- Theme updates\n"
"\nChanges in version 2013.5:\n\n"
"- Add command line window\n"
"- Uses curses display driver when appropriate\n"
"\nChanges in version 2013.4:\n\n"
"- Support for debugging generated code\n"
"\nChanges in version 2013.3.5:\n\n"
"- IPython fixes (Aaron Meurer)\n"
"- Py2/3 configuration fixes (Somchai Smythe)\n"
"- PyPy fixes (Julian Berman)\n"
"\nChanges in version 2013.3.4:\n\n"
"- Don't die if curses doesn't like what stdin/out are\n"
" connected to.\n"
"\nChanges in version 2013.3.3:\n\n"
"- As soon as pudb is loaded, you can break to the debugger by\n"
" evaluating the expression 'pu.db', where 'pu' is a new \n"
" 'builtin' that pudb has rudely shoved into the interpreter.\n"
"\nChanges in version 2013.3.2:\n\n"
"- Don't attempt to do signal handling if a signal handler\n"
" is already set (Fix by Buck Golemon).\n"
"\nChanges in version 2013.3.1:\n\n"
"- Don't ship {ez,distribute}_setup at all.\n"
" It breaks more than it helps.\n"
"\nChanges in version 2013.3:\n\n"
"- Switch to setuptools as a setup helper.\n"
"\nChanges in version 2013.2:\n\n"
"- Even more bug fixes.\n"
"\nChanges in version 2013.1:\n\n"
"- Ctrl-C will now break to the debugger in a way that does\n"
" not terminate the program\n"
"- Lots of bugs fixed\n"
"\nChanges in version 2012.3:\n\n"
"- Python 3 support (contributed by Brad Froehle)\n"
"- Better search box behavior (suggested by Ram Rachum)\n"
"- Made it possible to go back and examine state from "
"'finished' window. (suggested by Aaron Meurer)\n"
"\nChanges in version 2012.2.1:\n\n"
"- Don't touch config files during install.\n"
"\nChanges in version 2012.2:\n\n"
"- Add support for BPython as a shell.\n"
"- You can now run 'python -m pudb script.py' on Py 2.6+.\n"
" '-m pudb.run' still works--but it's four "
"keystrokes longer! :)\n"
"\nChanges in version 2012.1:\n\n"
"- Work around an API change in IPython 0.12.\n"
"\nChanges in version 2011.3.1:\n\n"
"- Work-around for bug in urwid >= 1.0.\n"
"\nChanges in version 2011.3:\n\n"
"- Finer-grained string highlighting "
"(contributed by Aaron Meurer)\n"
"- Prefs tweaks, instant-apply, top-down stack "
"(contributed by Aaron Meurer)\n"
"- Size changes in sidebar boxes (contributed by Aaron Meurer)\n"
"- New theme 'midnight' (contributed by Aaron Meurer)\n"
"- Support for IPython 0.11 (contributed by Chris Farrow)\n"
"- Suport for custom stringifiers "
"(contributed by Aaron Meurer)\n"
"- Line wrapping in variables view "
"(contributed by Aaron Meurer)\n"
"\nChanges in version 2011.2:\n\n"
"- Fix for post-mortem debugging (contributed by 'Sundance')\n"
"\nChanges in version 2011.1:\n\n"
"- Breakpoints saved between sessions\n"
"- A new 'dark vim' theme\n"
"(both contributed by Naveen Michaud-Agrawal)\n"
"\nChanges in version 0.93:\n\n"
"- Stored preferences (no more pesky IPython prompt!)\n"
"- Themes\n"
"- Line numbers (optional)\n"
% VERSION)
from pudb.settings import save_config
save_config(CONFIG)
self.run_edit_config()
try:
if toplevel is None:
toplevel = self.top
self.size = self.screen.get_cols_rows()
self.quit_event_loop = False
while not self.quit_event_loop:
canvas = toplevel.render(self.size, focus=True)
self.screen.draw_screen(self.size, canvas)
keys = self.screen.get_input()
for k in keys:
if k == "window resize":
self.size = self.screen.get_cols_rows()
else:
try:
toplevel.keypress(self.size, k)
except Exception:
self.show_internal_exc_dlg(sys.exc_info())
return self.quit_event_loop
finally:
self.quit_event_loop = prev_quit_loop
# }}}
# {{{ debugger-facing interface
def interaction(self, exc_tuple, show_exc_dialog=True):
self.current_exc_tuple = exc_tuple
from pudb import VERSION
caption = [(None,
"PuDB %s - ?:help n:next s:step into b:breakpoint "
"!:python command line"
% VERSION)]
if self.debugger.post_mortem:
if show_exc_dialog and exc_tuple is not None:
self.show_exception_dialog(exc_tuple)
caption.extend([
(None, " "),
("warning", "[POST-MORTEM MODE]")
])
elif exc_tuple is not None:
caption.extend([
(None, " "),
("warning", "[PROCESSING EXCEPTION - hit 'e' to examine]")
])
self.caption.set_text(caption)
self.event_loop()
def set_source_code_provider(self, source_code_provider, force_update=False):
if self.source_code_provider != source_code_provider or force_update:
self.source[:] = source_code_provider.get_lines(self)
self.source_code_provider = source_code_provider
self.current_line = None
def show_line(self, line, source_code_provider=None):
"""Updates the UI so that a certain line is currently in view."""
changed_file = False
if source_code_provider is not None:
changed_file = self.source_code_provider != source_code_provider
self.set_source_code_provider(source_code_provider)
line -= 1
if line >= 0 and line < len(self.source):
self.source_list.set_focus(line)
if changed_file:
self.source_list.set_focus_valign("middle")
def set_current_line(self, line, source_code_provider):
"""Updates the UI to show the line currently being executed."""
if self.current_line is not None:
self.current_line.set_current(False)
self.show_line(line, source_code_provider)
line -= 1
if line >= 0 and line < len(self.source):
self.current_line = self.source[line]
self.current_line.set_current(True)
def update_var_view(self, locals=None, globals=None, focus_index=None):
if locals is None:
locals = self.debugger.curframe.f_locals
if globals is None:
globals = self.debugger.curframe.f_globals
from pudb.var_view import make_var_view
self.locals[:] = make_var_view(
self.get_frame_var_info(read_only=True),
locals, globals)
if focus_index is not None:
# Have to set the focus _after_ updating the locals list, as there
# appears to be a brief moment while reseting the list when the
# list is empty but urwid will attempt to set the focus anyway,
# which causes problems.
try:
self.var_list._w.set_focus(focus_index)
except IndexError:
# sigh oh well we tried
pass
def _get_bp_list(self):
return [bp
for fn, bp_lst in self.debugger.get_all_breaks().items()
for lineno in bp_lst
for bp in self.debugger.get_breaks(fn, lineno)
if not bp.temporary]
def _format_fname(self, fname):
from os.path import dirname, basename
name = basename(fname)
if name == "__init__.py":
name = "..."+dirname(fname)[-10:]+"/"+name
return name
def update_breakpoints(self):
self.bp_walker[:] = [
BreakpointFrame(self.debugger.current_bp == (bp.file, bp.line),
self._format_fname(bp.file), bp)
for bp in self._get_bp_list()]
def update_stack(self):
def make_frame_ui(frame_lineno):
frame, lineno = frame_lineno
code = frame.f_code
class_name = None
if code.co_argcount and code.co_varnames[0] == "self":
try:
class_name = frame.f_locals["self"].__class__.__name__
except Exception:
from pudb.lowlevel import ui_log
message = "Failed to determine class name"
ui_log.exception(message)
class_name = "!! %s !!" % message
return StackFrame(frame is self.debugger.curframe,
code.co_name, class_name,
self._format_fname(code.co_filename), lineno)
frame_uis = [make_frame_ui(fl) for fl in self.debugger.stack]
if CONFIG["current_stack_frame"] == "top":
frame_uis = frame_uis[::-1]
elif CONFIG["current_stack_frame"] == "bottom":
pass
else:
raise ValueError("invalid value for 'current_stack_frame' pref")
self.stack_walker[:] = frame_uis
def update_cmdline_win(self):
self.set_cmdline_state(not CONFIG["hide_cmdline_win"])
# }}}
# vim: foldmethod=marker:expandtab:softtabstop=4
| 36.963899 | 106 | 0.547339 | [
"MIT"
] | chrisamow/pudb | pudb/debugger.py | 102,392 | Python |
import dis
import math
import os
import unittest
import sys
import ast
import _ast
import tempfile
import types
import textwrap
from test import support
from test.support import script_helper, requires_debug_ranges
from test.support.os_helper import FakePath
class TestSpecifics(unittest.TestCase):
def compile_single(self, source):
compile(source, "<single>", "single")
def assertInvalidSingle(self, source):
self.assertRaises(SyntaxError, self.compile_single, source)
def test_no_ending_newline(self):
compile("hi", "<test>", "exec")
compile("hi\r", "<test>", "exec")
def test_empty(self):
compile("", "<test>", "exec")
def test_other_newlines(self):
compile("\r\n", "<test>", "exec")
compile("\r", "<test>", "exec")
compile("hi\r\nstuff\r\ndef f():\n pass\r", "<test>", "exec")
compile("this_is\rreally_old_mac\rdef f():\n pass", "<test>", "exec")
def test_debug_assignment(self):
# catch assignments to __debug__
self.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single')
import builtins
prev = builtins.__debug__
setattr(builtins, '__debug__', 'sure')
self.assertEqual(__debug__, prev)
setattr(builtins, '__debug__', prev)
def test_argument_handling(self):
# detect duplicate positional and keyword arguments
self.assertRaises(SyntaxError, eval, 'lambda a,a:0')
self.assertRaises(SyntaxError, eval, 'lambda a,a=1:0')
self.assertRaises(SyntaxError, eval, 'lambda a=1,a=1:0')
self.assertRaises(SyntaxError, exec, 'def f(a, a): pass')
self.assertRaises(SyntaxError, exec, 'def f(a = 0, a = 1): pass')
self.assertRaises(SyntaxError, exec, 'def f(a): global a; a = 1')
def test_syntax_error(self):
self.assertRaises(SyntaxError, compile, "1+*3", "filename", "exec")
def test_none_keyword_arg(self):
self.assertRaises(SyntaxError, compile, "f(None=1)", "<string>", "exec")
def test_duplicate_global_local(self):
self.assertRaises(SyntaxError, exec, 'def f(a): global a; a = 1')
def test_exec_with_general_mapping_for_locals(self):
class M:
"Test mapping interface versus possible calls from eval()."
def __getitem__(self, key):
if key == 'a':
return 12
raise KeyError
def __setitem__(self, key, value):
self.results = (key, value)
def keys(self):
return list('xyz')
m = M()
g = globals()
exec('z = a', g, m)
self.assertEqual(m.results, ('z', 12))
try:
exec('z = b', g, m)
except NameError:
pass
else:
self.fail('Did not detect a KeyError')
exec('z = dir()', g, m)
self.assertEqual(m.results, ('z', list('xyz')))
exec('z = globals()', g, m)
self.assertEqual(m.results, ('z', g))
exec('z = locals()', g, m)
self.assertEqual(m.results, ('z', m))
self.assertRaises(TypeError, exec, 'z = b', m)
class A:
"Non-mapping"
pass
m = A()
self.assertRaises(TypeError, exec, 'z = a', g, m)
# Verify that dict subclasses work as well
class D(dict):
def __getitem__(self, key):
if key == 'a':
return 12
return dict.__getitem__(self, key)
d = D()
exec('z = a', g, d)
self.assertEqual(d['z'], 12)
def test_extended_arg(self):
longexpr = 'x = x or ' + '-x' * 2500
g = {}
code = '''
def f(x):
%s
%s
%s
%s
%s
%s
%s
%s
%s
%s
# the expressions above have no effect, x == argument
while x:
x -= 1
# EXTENDED_ARG/JUMP_ABSOLUTE here
return x
''' % ((longexpr,)*10)
exec(code, g)
self.assertEqual(g['f'](5), 0)
def test_argument_order(self):
self.assertRaises(SyntaxError, exec, 'def f(a=1, b): pass')
def test_float_literals(self):
# testing bad float literals
self.assertRaises(SyntaxError, eval, "2e")
self.assertRaises(SyntaxError, eval, "2.0e+")
self.assertRaises(SyntaxError, eval, "1e-")
self.assertRaises(SyntaxError, eval, "3-4e/21")
def test_indentation(self):
# testing compile() of indented block w/o trailing newline"
s = """
if 1:
if 2:
pass"""
compile(s, "<string>", "exec")
# This test is probably specific to CPython and may not generalize
# to other implementations. We are trying to ensure that when
# the first line of code starts after 256, correct line numbers
# in tracebacks are still produced.
def test_leading_newlines(self):
s256 = "".join(["\n"] * 256 + ["spam"])
co = compile(s256, 'fn', 'exec')
self.assertEqual(co.co_firstlineno, 1)
self.assertEqual(list(co.co_lines()), [(0, 2, None), (2, 10, 257)])
def test_literals_with_leading_zeroes(self):
for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",
"080000000000000", "000000000000009", "000000000000008",
"0b42", "0BADCAFE", "0o123456789", "0b1.1", "0o4.2",
"0b101j", "0o153j", "0b100e1", "0o777e1", "0777",
"000777", "000000000000007"]:
self.assertRaises(SyntaxError, eval, arg)
self.assertEqual(eval("0xff"), 255)
self.assertEqual(eval("0777."), 777)
self.assertEqual(eval("0777.0"), 777)
self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
self.assertEqual(eval("0777e1"), 7770)
self.assertEqual(eval("0e0"), 0)
self.assertEqual(eval("0000e-012"), 0)
self.assertEqual(eval("09.5"), 9.5)
self.assertEqual(eval("0777j"), 777j)
self.assertEqual(eval("000"), 0)
self.assertEqual(eval("00j"), 0j)
self.assertEqual(eval("00.0"), 0)
self.assertEqual(eval("0e3"), 0)
self.assertEqual(eval("090000000000000."), 90000000000000.)
self.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
self.assertEqual(eval("090000000000000e0"), 90000000000000.)
self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
self.assertEqual(eval("090000000000000j"), 90000000000000j)
self.assertEqual(eval("000000000000008."), 8.)
self.assertEqual(eval("000000000000009."), 9.)
self.assertEqual(eval("0b101010"), 42)
self.assertEqual(eval("-0b000000000010"), -2)
self.assertEqual(eval("0o777"), 511)
self.assertEqual(eval("-0o0000010"), -8)
def test_unary_minus(self):
# Verify treatment of unary minus on negative numbers SF bug #660455
if sys.maxsize == 2147483647:
# 32-bit machine
all_one_bits = '0xffffffff'
self.assertEqual(eval(all_one_bits), 4294967295)
self.assertEqual(eval("-" + all_one_bits), -4294967295)
elif sys.maxsize == 9223372036854775807:
# 64-bit machine
all_one_bits = '0xffffffffffffffff'
self.assertEqual(eval(all_one_bits), 18446744073709551615)
self.assertEqual(eval("-" + all_one_bits), -18446744073709551615)
else:
self.fail("How many bits *does* this machine have???")
# Verify treatment of constant folding on -(sys.maxsize+1)
# i.e. -2147483648 on 32 bit platforms. Should return int.
self.assertIsInstance(eval("%s" % (-sys.maxsize - 1)), int)
self.assertIsInstance(eval("%s" % (-sys.maxsize - 2)), int)
if sys.maxsize == 9223372036854775807:
def test_32_63_bit_values(self):
a = +4294967296 # 1 << 32
b = -4294967296 # 1 << 32
c = +281474976710656 # 1 << 48
d = -281474976710656 # 1 << 48
e = +4611686018427387904 # 1 << 62
f = -4611686018427387904 # 1 << 62
g = +9223372036854775807 # 1 << 63 - 1
h = -9223372036854775807 # 1 << 63 - 1
for variable in self.test_32_63_bit_values.__code__.co_consts:
if variable is not None:
self.assertIsInstance(variable, int)
def test_sequence_unpacking_error(self):
# Verify sequence packing/unpacking with "or". SF bug #757818
i,j = (1, -1) or (-1, 1)
self.assertEqual(i, 1)
self.assertEqual(j, -1)
def test_none_assignment(self):
stmts = [
'None = 0',
'None += 0',
'__builtins__.None = 0',
'def None(): pass',
'class None: pass',
'(a, None) = 0, 0',
'for None in range(10): pass',
'def f(None): pass',
'import None',
'import x as None',
'from x import None',
'from x import y as None'
]
for stmt in stmts:
stmt += "\n"
self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
def test_import(self):
succeed = [
'import sys',
'import os, sys',
'import os as bar',
'import os.path as bar',
'from __future__ import nested_scopes, generators',
'from __future__ import (nested_scopes,\ngenerators)',
'from __future__ import (nested_scopes,\ngenerators,)',
'from sys import stdin, stderr, stdout',
'from sys import (stdin, stderr,\nstdout)',
'from sys import (stdin, stderr,\nstdout,)',
'from sys import (stdin\n, stderr, stdout)',
'from sys import (stdin\n, stderr, stdout,)',
'from sys import stdin as si, stdout as so, stderr as se',
'from sys import (stdin as si, stdout as so, stderr as se)',
'from sys import (stdin as si, stdout as so, stderr as se,)',
]
fail = [
'import (os, sys)',
'import (os), (sys)',
'import ((os), (sys))',
'import (sys',
'import sys)',
'import (os,)',
'import os As bar',
'import os.path a bar',
'from sys import stdin As stdout',
'from sys import stdin a stdout',
'from (sys) import stdin',
'from __future__ import (nested_scopes',
'from __future__ import nested_scopes)',
'from __future__ import nested_scopes,\ngenerators',
'from sys import (stdin',
'from sys import stdin)',
'from sys import stdin, stdout,\nstderr',
'from sys import stdin si',
'from sys import stdin,',
'from sys import (*)',
'from sys import (stdin,, stdout, stderr)',
'from sys import (stdin, stdout),',
]
for stmt in succeed:
compile(stmt, 'tmp', 'exec')
for stmt in fail:
self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
def test_for_distinct_code_objects(self):
# SF bug 1048870
def f():
f1 = lambda x=1: x
f2 = lambda x=2: x
return f1, f2
f1, f2 = f()
self.assertNotEqual(id(f1.__code__), id(f2.__code__))
def test_lambda_doc(self):
l = lambda: "foo"
self.assertIsNone(l.__doc__)
def test_encoding(self):
code = b'# -*- coding: badencoding -*-\npass\n'
self.assertRaises(SyntaxError, compile, code, 'tmp', 'exec')
code = '# -*- coding: badencoding -*-\n"\xc2\xa4"\n'
compile(code, 'tmp', 'exec')
self.assertEqual(eval(code), '\xc2\xa4')
code = '"\xc2\xa4"\n'
self.assertEqual(eval(code), '\xc2\xa4')
code = b'"\xc2\xa4"\n'
self.assertEqual(eval(code), '\xa4')
code = b'# -*- coding: latin1 -*-\n"\xc2\xa4"\n'
self.assertEqual(eval(code), '\xc2\xa4')
code = b'# -*- coding: utf-8 -*-\n"\xc2\xa4"\n'
self.assertEqual(eval(code), '\xa4')
code = b'# -*- coding: iso8859-15 -*-\n"\xc2\xa4"\n'
self.assertEqual(eval(code), '\xc2\u20ac')
code = '"""\\\n# -*- coding: iso8859-15 -*-\n\xc2\xa4"""\n'
self.assertEqual(eval(code), '# -*- coding: iso8859-15 -*-\n\xc2\xa4')
code = b'"""\\\n# -*- coding: iso8859-15 -*-\n\xc2\xa4"""\n'
self.assertEqual(eval(code), '# -*- coding: iso8859-15 -*-\n\xa4')
def test_subscripts(self):
# SF bug 1448804
# Class to make testing subscript results easy
class str_map(object):
def __init__(self):
self.data = {}
def __getitem__(self, key):
return self.data[str(key)]
def __setitem__(self, key, value):
self.data[str(key)] = value
def __delitem__(self, key):
del self.data[str(key)]
def __contains__(self, key):
return str(key) in self.data
d = str_map()
# Index
d[1] = 1
self.assertEqual(d[1], 1)
d[1] += 1
self.assertEqual(d[1], 2)
del d[1]
self.assertNotIn(1, d)
# Tuple of indices
d[1, 1] = 1
self.assertEqual(d[1, 1], 1)
d[1, 1] += 1
self.assertEqual(d[1, 1], 2)
del d[1, 1]
self.assertNotIn((1, 1), d)
# Simple slice
d[1:2] = 1
self.assertEqual(d[1:2], 1)
d[1:2] += 1
self.assertEqual(d[1:2], 2)
del d[1:2]
self.assertNotIn(slice(1, 2), d)
# Tuple of simple slices
d[1:2, 1:2] = 1
self.assertEqual(d[1:2, 1:2], 1)
d[1:2, 1:2] += 1
self.assertEqual(d[1:2, 1:2], 2)
del d[1:2, 1:2]
self.assertNotIn((slice(1, 2), slice(1, 2)), d)
# Extended slice
d[1:2:3] = 1
self.assertEqual(d[1:2:3], 1)
d[1:2:3] += 1
self.assertEqual(d[1:2:3], 2)
del d[1:2:3]
self.assertNotIn(slice(1, 2, 3), d)
# Tuple of extended slices
d[1:2:3, 1:2:3] = 1
self.assertEqual(d[1:2:3, 1:2:3], 1)
d[1:2:3, 1:2:3] += 1
self.assertEqual(d[1:2:3, 1:2:3], 2)
del d[1:2:3, 1:2:3]
self.assertNotIn((slice(1, 2, 3), slice(1, 2, 3)), d)
# Ellipsis
d[...] = 1
self.assertEqual(d[...], 1)
d[...] += 1
self.assertEqual(d[...], 2)
del d[...]
self.assertNotIn(Ellipsis, d)
# Tuple of Ellipses
d[..., ...] = 1
self.assertEqual(d[..., ...], 1)
d[..., ...] += 1
self.assertEqual(d[..., ...], 2)
del d[..., ...]
self.assertNotIn((Ellipsis, Ellipsis), d)
def test_annotation_limit(self):
# more than 255 annotations, should compile ok
s = "def f(%s): pass"
s %= ', '.join('a%d:%d' % (i,i) for i in range(300))
compile(s, '?', 'exec')
def test_mangling(self):
class A:
def f():
__mangled = 1
__not_mangled__ = 2
import __mangled_mod
import __package__.module
self.assertIn("_A__mangled", A.f.__code__.co_varnames)
self.assertIn("__not_mangled__", A.f.__code__.co_varnames)
self.assertIn("_A__mangled_mod", A.f.__code__.co_varnames)
self.assertIn("__package__", A.f.__code__.co_varnames)
def test_compile_ast(self):
fname = __file__
if fname.lower().endswith('pyc'):
fname = fname[:-1]
with open(fname, encoding='utf-8') as f:
fcontents = f.read()
sample_code = [
['<assign>', 'x = 5'],
['<ifblock>', """if True:\n pass\n"""],
['<forblock>', """for n in [1, 2, 3]:\n print(n)\n"""],
['<deffunc>', """def foo():\n pass\nfoo()\n"""],
[fname, fcontents],
]
for fname, code in sample_code:
co1 = compile(code, '%s1' % fname, 'exec')
ast = compile(code, '%s2' % fname, 'exec', _ast.PyCF_ONLY_AST)
self.assertTrue(type(ast) == _ast.Module)
co2 = compile(ast, '%s3' % fname, 'exec')
self.assertEqual(co1, co2)
# the code object's filename comes from the second compilation step
self.assertEqual(co2.co_filename, '%s3' % fname)
# raise exception when node type doesn't match with compile mode
co1 = compile('print(1)', '<string>', 'exec', _ast.PyCF_ONLY_AST)
self.assertRaises(TypeError, compile, co1, '<ast>', 'eval')
# raise exception when node type is no start node
self.assertRaises(TypeError, compile, _ast.If(), '<ast>', 'exec')
# raise exception when node has invalid children
ast = _ast.Module()
ast.body = [_ast.BoolOp()]
self.assertRaises(TypeError, compile, ast, '<ast>', 'exec')
def test_dict_evaluation_order(self):
i = 0
def f():
nonlocal i
i += 1
return i
d = {f(): f(), f(): f()}
self.assertEqual(d, {1: 2, 3: 4})
def test_compile_filename(self):
for filename in 'file.py', b'file.py':
code = compile('pass', filename, 'exec')
self.assertEqual(code.co_filename, 'file.py')
for filename in bytearray(b'file.py'), memoryview(b'file.py'):
with self.assertWarns(DeprecationWarning):
code = compile('pass', filename, 'exec')
self.assertEqual(code.co_filename, 'file.py')
self.assertRaises(TypeError, compile, 'pass', list(b'file.py'), 'exec')
@support.cpython_only
def test_same_filename_used(self):
s = """def f(): pass\ndef g(): pass"""
c = compile(s, "myfile", "exec")
for obj in c.co_consts:
if isinstance(obj, types.CodeType):
self.assertIs(obj.co_filename, c.co_filename)
def test_single_statement(self):
self.compile_single("1 + 2")
self.compile_single("\n1 + 2")
self.compile_single("1 + 2\n")
self.compile_single("1 + 2\n\n")
self.compile_single("1 + 2\t\t\n")
self.compile_single("1 + 2\t\t\n ")
self.compile_single("1 + 2 # one plus two")
self.compile_single("1; 2")
self.compile_single("import sys; sys")
self.compile_single("def f():\n pass")
self.compile_single("while False:\n pass")
self.compile_single("if x:\n f(x)")
self.compile_single("if x:\n f(x)\nelse:\n g(x)")
self.compile_single("class T:\n pass")
self.compile_single("c = '''\na=1\nb=2\nc=3\n'''")
def test_bad_single_statement(self):
self.assertInvalidSingle('1\n2')
self.assertInvalidSingle('def f(): pass')
self.assertInvalidSingle('a = 13\nb = 187')
self.assertInvalidSingle('del x\ndel y')
self.assertInvalidSingle('f()\ng()')
self.assertInvalidSingle('f()\n# blah\nblah()')
self.assertInvalidSingle('f()\nxy # blah\nblah()')
self.assertInvalidSingle('x = 5 # comment\nx = 6\n')
self.assertInvalidSingle("c = '''\nd=1\n'''\na = 1\n\nb = 2\n")
def test_particularly_evil_undecodable(self):
# Issue 24022
src = b'0000\x00\n00000000000\n\x00\n\x9e\n'
with tempfile.TemporaryDirectory() as tmpd:
fn = os.path.join(tmpd, "bad.py")
with open(fn, "wb") as fp:
fp.write(src)
res = script_helper.run_python_until_end(fn)[0]
self.assertIn(b"Non-UTF-8", res.err)
def test_yet_more_evil_still_undecodable(self):
# Issue #25388
src = b"#\x00\n#\xfd\n"
with tempfile.TemporaryDirectory() as tmpd:
fn = os.path.join(tmpd, "bad.py")
with open(fn, "wb") as fp:
fp.write(src)
res = script_helper.run_python_until_end(fn)[0]
self.assertIn(b"Non-UTF-8", res.err)
@support.cpython_only
def test_compiler_recursion_limit(self):
# Expected limit is sys.getrecursionlimit() * the scaling factor
# in symtable.c (currently 3)
# We expect to fail *at* that limit, because we use up some of
# the stack depth limit in the test suite code
# So we check the expected limit and 75% of that
# XXX (ncoghlan): duplicating the scaling factor here is a little
# ugly. Perhaps it should be exposed somewhere...
fail_depth = sys.getrecursionlimit() * 3
crash_depth = sys.getrecursionlimit() * 300
success_depth = int(fail_depth * 0.75)
def check_limit(prefix, repeated, mode="single"):
expect_ok = prefix + repeated * success_depth
compile(expect_ok, '<test>', mode)
for depth in (fail_depth, crash_depth):
broken = prefix + repeated * depth
details = "Compiling ({!r} + {!r} * {})".format(
prefix, repeated, depth)
with self.assertRaises(RecursionError, msg=details):
compile(broken, '<test>', mode)
check_limit("a", "()")
check_limit("a", ".b")
check_limit("a", "[0]")
check_limit("a", "*a")
# XXX Crashes in the parser.
# check_limit("a", " if a else a")
# check_limit("if a: pass", "\nelif a: pass", mode="exec")
def test_null_terminated(self):
# The source code is null-terminated internally, but bytes-like
# objects are accepted, which could be not terminated.
with self.assertRaisesRegex(ValueError, "cannot contain null"):
compile("123\x00", "<dummy>", "eval")
with self.assertRaisesRegex(ValueError, "cannot contain null"):
compile(memoryview(b"123\x00"), "<dummy>", "eval")
code = compile(memoryview(b"123\x00")[1:-1], "<dummy>", "eval")
self.assertEqual(eval(code), 23)
code = compile(memoryview(b"1234")[1:-1], "<dummy>", "eval")
self.assertEqual(eval(code), 23)
code = compile(memoryview(b"$23$")[1:-1], "<dummy>", "eval")
self.assertEqual(eval(code), 23)
# Also test when eval() and exec() do the compilation step
self.assertEqual(eval(memoryview(b"1234")[1:-1]), 23)
namespace = dict()
exec(memoryview(b"ax = 123")[1:-1], namespace)
self.assertEqual(namespace['x'], 12)
def check_constant(self, func, expected):
for const in func.__code__.co_consts:
if repr(const) == repr(expected):
break
else:
self.fail("unable to find constant %r in %r"
% (expected, func.__code__.co_consts))
# Merging equal constants is not a strict requirement for the Python
# semantics, it's a more an implementation detail.
@support.cpython_only
def test_merge_constants(self):
# Issue #25843: compile() must merge constants which are equal
# and have the same type.
def check_same_constant(const):
ns = {}
code = "f1, f2 = lambda: %r, lambda: %r" % (const, const)
exec(code, ns)
f1 = ns['f1']
f2 = ns['f2']
self.assertIs(f1.__code__, f2.__code__)
self.check_constant(f1, const)
self.assertEqual(repr(f1()), repr(const))
check_same_constant(None)
check_same_constant(0)
check_same_constant(0.0)
check_same_constant(b'abc')
check_same_constant('abc')
# Note: "lambda: ..." emits "LOAD_CONST Ellipsis",
# whereas "lambda: Ellipsis" emits "LOAD_GLOBAL Ellipsis"
f1, f2 = lambda: ..., lambda: ...
self.assertIs(f1.__code__, f2.__code__)
self.check_constant(f1, Ellipsis)
self.assertEqual(repr(f1()), repr(Ellipsis))
# Merge constants in tuple or frozenset
f1, f2 = lambda: "not a name", lambda: ("not a name",)
f3 = lambda x: x in {("not a name",)}
self.assertIs(f1.__code__.co_consts[1],
f2.__code__.co_consts[1][0])
self.assertIs(next(iter(f3.__code__.co_consts[1])),
f2.__code__.co_consts[1])
# {0} is converted to a constant frozenset({0}) by the peephole
# optimizer
f1, f2 = lambda x: x in {0}, lambda x: x in {0}
self.assertIs(f1.__code__, f2.__code__)
self.check_constant(f1, frozenset({0}))
self.assertTrue(f1(0))
# Merging equal co_linetable and co_code is not a strict requirement
# for the Python semantics, it's a more an implementation detail.
@support.cpython_only
def test_merge_code_attrs(self):
# See https://bugs.python.org/issue42217
f1 = lambda x: x.y.z
f2 = lambda a: a.b.c
self.assertIs(f1.__code__.co_linetable, f2.__code__.co_linetable)
self.assertIs(f1.__code__.co_code, f2.__code__.co_code)
# Stripping unused constants is not a strict requirement for the
# Python semantics, it's a more an implementation detail.
@support.cpython_only
def test_strip_unused_consts(self):
# Python 3.10rc1 appended None to co_consts when None is not used
# at all. See bpo-45056.
def f1():
"docstring"
return 42
self.assertEqual(f1.__code__.co_consts, ("docstring", 42))
# This is a regression test for a CPython specific peephole optimizer
# implementation bug present in a few releases. It's assertion verifies
# that peephole optimization was actually done though that isn't an
# indication of the bugs presence or not (crashing is).
@support.cpython_only
def test_peephole_opt_unreachable_code_array_access_in_bounds(self):
"""Regression test for issue35193 when run under clang msan."""
def unused_code_at_end():
return 3
raise RuntimeError("unreachable")
# The above function definition will trigger the out of bounds
# bug in the peephole optimizer as it scans opcodes past the
# RETURN_VALUE opcode. This does not always crash an interpreter.
# When you build with the clang memory sanitizer it reliably aborts.
self.assertEqual(
'RETURN_VALUE',
list(dis.get_instructions(unused_code_at_end))[-1].opname)
def test_dont_merge_constants(self):
# Issue #25843: compile() must not merge constants which are equal
# but have a different type.
def check_different_constants(const1, const2):
ns = {}
exec("f1, f2 = lambda: %r, lambda: %r" % (const1, const2), ns)
f1 = ns['f1']
f2 = ns['f2']
self.assertIsNot(f1.__code__, f2.__code__)
self.assertNotEqual(f1.__code__, f2.__code__)
self.check_constant(f1, const1)
self.check_constant(f2, const2)
self.assertEqual(repr(f1()), repr(const1))
self.assertEqual(repr(f2()), repr(const2))
check_different_constants(0, 0.0)
check_different_constants(+0.0, -0.0)
check_different_constants((0,), (0.0,))
check_different_constants('a', b'a')
check_different_constants(('a',), (b'a',))
# check_different_constants() cannot be used because repr(-0j) is
# '(-0-0j)', but when '(-0-0j)' is evaluated to 0j: we loose the sign.
f1, f2 = lambda: +0.0j, lambda: -0.0j
self.assertIsNot(f1.__code__, f2.__code__)
self.check_constant(f1, +0.0j)
self.check_constant(f2, -0.0j)
self.assertEqual(repr(f1()), repr(+0.0j))
self.assertEqual(repr(f2()), repr(-0.0j))
# {0} is converted to a constant frozenset({0}) by the peephole
# optimizer
f1, f2 = lambda x: x in {0}, lambda x: x in {0.0}
self.assertIsNot(f1.__code__, f2.__code__)
self.check_constant(f1, frozenset({0}))
self.check_constant(f2, frozenset({0.0}))
self.assertTrue(f1(0))
self.assertTrue(f2(0.0))
def test_path_like_objects(self):
# An implicit test for PyUnicode_FSDecoder().
compile("42", FakePath("test_compile_pathlike"), "single")
def test_stack_overflow(self):
# bpo-31113: Stack overflow when compile a long sequence of
# complex statements.
compile("if a: b\n" * 200000, "<dummy>", "exec")
# Multiple users rely on the fact that CPython does not generate
# bytecode for dead code blocks. See bpo-37500 for more context.
@support.cpython_only
def test_dead_blocks_do_not_generate_bytecode(self):
def unused_block_if():
if 0:
return 42
def unused_block_while():
while 0:
return 42
def unused_block_if_else():
if 1:
return None
else:
return 42
def unused_block_while_else():
while 1:
return None
else:
return 42
funcs = [unused_block_if, unused_block_while,
unused_block_if_else, unused_block_while_else]
for func in funcs:
opcodes = list(dis.get_instructions(func))
self.assertLessEqual(len(opcodes), 4)
self.assertEqual('LOAD_CONST', opcodes[-2].opname)
self.assertEqual(None, opcodes[-2].argval)
self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
def test_false_while_loop(self):
def break_in_while():
while False:
break
def continue_in_while():
while False:
continue
funcs = [break_in_while, continue_in_while]
# Check that we did not raise but we also don't generate bytecode
for func in funcs:
opcodes = list(dis.get_instructions(func))
self.assertEqual(3, len(opcodes))
self.assertEqual('LOAD_CONST', opcodes[1].opname)
self.assertEqual(None, opcodes[1].argval)
self.assertEqual('RETURN_VALUE', opcodes[2].opname)
def test_consts_in_conditionals(self):
def and_true(x):
return True and x
def and_false(x):
return False and x
def or_true(x):
return True or x
def or_false(x):
return False or x
funcs = [and_true, and_false, or_true, or_false]
# Check that condition is removed.
for func in funcs:
with self.subTest(func=func):
opcodes = list(dis.get_instructions(func))
self.assertLessEqual(len(opcodes), 3)
self.assertIn('LOAD_', opcodes[-2].opname)
self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
def test_imported_load_method(self):
sources = [
"""\
import os
def foo():
return os.uname()
""",
"""\
import os as operating_system
def foo():
return operating_system.uname()
""",
"""\
from os import path
def foo(x):
return path.join(x)
""",
"""\
from os import path as os_path
def foo(x):
return os_path.join(x)
"""
]
for source in sources:
namespace = {}
exec(textwrap.dedent(source), namespace)
func = namespace['foo']
with self.subTest(func=func.__name__):
opcodes = list(dis.get_instructions(func))
instructions = [opcode.opname for opcode in opcodes]
self.assertNotIn('LOAD_METHOD', instructions)
self.assertIn('LOAD_ATTR', instructions)
self.assertIn('PRECALL', instructions)
def test_lineno_procedure_call(self):
def call():
(
print()
)
line1 = call.__code__.co_firstlineno + 1
assert line1 not in [line for (_, _, line) in call.__code__.co_lines()]
def test_lineno_after_implicit_return(self):
TRUE = True
# Don't use constant True or False, as compiler will remove test
def if1(x):
x()
if TRUE:
pass
def if2(x):
x()
if TRUE:
pass
else:
pass
def if3(x):
x()
if TRUE:
pass
else:
return None
def if4(x):
x()
if not TRUE:
pass
funcs = [ if1, if2, if3, if4]
lastlines = [ 3, 3, 3, 2]
frame = None
def save_caller_frame():
nonlocal frame
frame = sys._getframe(1)
for func, lastline in zip(funcs, lastlines, strict=True):
with self.subTest(func=func):
func(save_caller_frame)
self.assertEqual(frame.f_lineno-frame.f_code.co_firstlineno, lastline)
def test_lineno_after_no_code(self):
def no_code1():
"doc string"
def no_code2():
a: int
for func in (no_code1, no_code2):
with self.subTest(func=func):
code = func.__code__
lines = list(code.co_lines())
self.assertEqual(len(lines), 1)
start, end, line = lines[0]
self.assertEqual(start, 0)
self.assertEqual(end, len(code.co_code))
self.assertEqual(line, code.co_firstlineno)
def test_lineno_attribute(self):
def load_attr():
return (
o.
a
)
load_attr_lines = [ 0, 2, 3, 1 ]
def load_method():
return (
o.
m(
0
)
)
load_method_lines = [ 0, 2, 3, 4, 3, 1 ]
def store_attr():
(
o.
a
) = (
v
)
store_attr_lines = [ 0, 5, 2, 3 ]
def aug_store_attr():
(
o.
a
) += (
v
)
aug_store_attr_lines = [ 0, 2, 3, 5, 1, 3 ]
funcs = [ load_attr, load_method, store_attr, aug_store_attr]
func_lines = [ load_attr_lines, load_method_lines,
store_attr_lines, aug_store_attr_lines]
for func, lines in zip(funcs, func_lines, strict=True):
with self.subTest(func=func):
code_lines = [ line-func.__code__.co_firstlineno
for (_, _, line) in func.__code__.co_lines()
if line is not None ]
self.assertEqual(lines, code_lines)
def test_line_number_genexp(self):
def return_genexp():
return (1
for
x
in
y)
genexp_lines = [1, 3, 1]
genexp_code = return_genexp.__code__.co_consts[1]
code_lines = [ None if line is None else line-return_genexp.__code__.co_firstlineno
for (_, _, line) in genexp_code.co_lines() ]
self.assertEqual(genexp_lines, code_lines)
def test_line_number_implicit_return_after_async_for(self):
async def test(aseq):
async for i in aseq:
body
expected_lines = [0, 1, 2, 1]
code_lines = [ None if line is None else line-test.__code__.co_firstlineno
for (_, _, line) in test.__code__.co_lines() ]
self.assertEqual(expected_lines, code_lines)
def test_big_dict_literal(self):
# The compiler has a flushing point in "compiler_dict" that calls compiles
# a portion of the dictionary literal when the loop that iterates over the items
# reaches 0xFFFF elements but the code was not including the boundary element,
# dropping the key at position 0xFFFF. See bpo-41531 for more information
dict_size = 0xFFFF + 1
the_dict = "{" + ",".join(f"{x}:{x}" for x in range(dict_size)) + "}"
self.assertEqual(len(eval(the_dict)), dict_size)
def test_redundant_jump_in_if_else_break(self):
# Check if bytecode containing jumps that simply point to the next line
# is generated around if-else-break style structures. See bpo-42615.
def if_else_break():
val = 1
while True:
if val > 0:
val -= 1
else:
break
val = -1
INSTR_SIZE = 2
HANDLED_JUMPS = (
'POP_JUMP_IF_FALSE',
'POP_JUMP_IF_TRUE',
'JUMP_ABSOLUTE',
'JUMP_FORWARD',
)
for line, instr in enumerate(
dis.Bytecode(if_else_break, show_caches=True)
):
if instr.opname == 'JUMP_FORWARD':
self.assertNotEqual(instr.arg, 0)
elif instr.opname in HANDLED_JUMPS:
self.assertNotEqual(instr.arg, (line + 1)*INSTR_SIZE)
def test_no_wraparound_jump(self):
# See https://bugs.python.org/issue46724
def while_not_chained(a, b, c):
while not (a < b < c):
pass
for instr in dis.Bytecode(while_not_chained):
self.assertNotEqual(instr.opname, "EXTENDED_ARG")
@requires_debug_ranges()
class TestSourcePositions(unittest.TestCase):
# Ensure that compiled code snippets have correct line and column numbers
# in `co_positions()`.
def check_positions_against_ast(self, snippet):
# Basic check that makes sure each line and column is at least present
# in one of the AST nodes of the source code.
code = compile(snippet, 'test_compile.py', 'exec')
ast_tree = compile(snippet, 'test_compile.py', 'exec', _ast.PyCF_ONLY_AST)
self.assertTrue(type(ast_tree) == _ast.Module)
# Use an AST visitor that notes all the offsets.
lines, end_lines, columns, end_columns = set(), set(), set(), set()
class SourceOffsetVisitor(ast.NodeVisitor):
def generic_visit(self, node):
super().generic_visit(node)
if not isinstance(node, ast.expr) and not isinstance(node, ast.stmt):
return
lines.add(node.lineno)
end_lines.add(node.end_lineno)
columns.add(node.col_offset)
end_columns.add(node.end_col_offset)
SourceOffsetVisitor().visit(ast_tree)
# Check against the positions in the code object.
for (line, end_line, col, end_col) in code.co_positions():
# If the offset is not None (indicating missing data), ensure that
# it was part of one of the AST nodes.
if line is not None:
self.assertIn(line, lines)
if end_line is not None:
self.assertIn(end_line, end_lines)
if col is not None:
self.assertIn(col, columns)
if end_col is not None:
self.assertIn(end_col, end_columns)
return code, ast_tree
def assertOpcodeSourcePositionIs(self, code, opcode,
line, end_line, column, end_column, occurrence=1):
for instr, position in zip(
dis.Bytecode(code, show_caches=True), code.co_positions(), strict=True
):
if instr.opname == opcode:
occurrence -= 1
if not occurrence:
self.assertEqual(position[0], line)
self.assertEqual(position[1], end_line)
self.assertEqual(position[2], column)
self.assertEqual(position[3], end_column)
return
self.fail(f"Opcode {opcode} not found in code")
def test_simple_assignment(self):
snippet = "x = 1"
self.check_positions_against_ast(snippet)
def test_compiles_to_extended_op_arg(self):
# Make sure we still have valid positions when the code compiles to an
# EXTENDED_ARG by performing a loop which needs a JUMP_ABSOLUTE after
# a bunch of opcodes.
snippet = "x = x\n" * 10_000
snippet += ("while x != 0:\n"
" x -= 1\n"
"while x != 0:\n"
" x += 1\n"
)
compiled_code, _ = self.check_positions_against_ast(snippet)
self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
line=10_000 + 2, end_line=10_000 + 2,
column=2, end_column=8, occurrence=1)
self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
line=10_000 + 4, end_line=10_000 + 4,
column=2, end_column=9, occurrence=2)
def test_multiline_expression(self):
snippet = """\
f(
1, 2, 3, 4
)
"""
compiled_code, _ = self.check_positions_against_ast(snippet)
self.assertOpcodeSourcePositionIs(compiled_code, 'CALL',
line=1, end_line=3, column=0, end_column=1)
def test_very_long_line_end_offset(self):
# Make sure we get None for when the column offset is too large to
# store in a byte.
long_string = "a" * 1000
snippet = f"g('{long_string}')"
compiled_code, _ = self.check_positions_against_ast(snippet)
self.assertOpcodeSourcePositionIs(compiled_code, 'CALL',
line=1, end_line=1, column=None, end_column=None)
def test_complex_single_line_expression(self):
snippet = "a - b @ (c * x['key'] + 23)"
compiled_code, _ = self.check_positions_against_ast(snippet)
self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_SUBSCR',
line=1, end_line=1, column=13, end_column=21)
self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
line=1, end_line=1, column=9, end_column=21, occurrence=1)
self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
line=1, end_line=1, column=9, end_column=26, occurrence=2)
self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
line=1, end_line=1, column=4, end_column=27, occurrence=3)
self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
line=1, end_line=1, column=0, end_column=27, occurrence=4)
class TestExpressionStackSize(unittest.TestCase):
# These tests check that the computed stack size for a code object
# stays within reasonable bounds (see issue #21523 for an example
# dysfunction).
N = 100
def check_stack_size(self, code):
# To assert that the alleged stack size is not O(N), we
# check that it is smaller than log(N).
if isinstance(code, str):
code = compile(code, "<foo>", "single")
max_size = math.ceil(math.log(len(code.co_code)))
self.assertLessEqual(code.co_stacksize, max_size)
def test_and(self):
self.check_stack_size("x and " * self.N + "x")
def test_or(self):
self.check_stack_size("x or " * self.N + "x")
def test_and_or(self):
self.check_stack_size("x and x or " * self.N + "x")
def test_chained_comparison(self):
self.check_stack_size("x < " * self.N + "x")
def test_if_else(self):
self.check_stack_size("x if x else " * self.N + "x")
def test_binop(self):
self.check_stack_size("x + " * self.N + "x")
def test_list(self):
self.check_stack_size("[" + "x, " * self.N + "x]")
def test_tuple(self):
self.check_stack_size("(" + "x, " * self.N + "x)")
def test_set(self):
self.check_stack_size("{" + "x, " * self.N + "x}")
def test_dict(self):
self.check_stack_size("{" + "x:x, " * self.N + "x:x}")
def test_func_args(self):
self.check_stack_size("f(" + "x, " * self.N + ")")
def test_func_kwargs(self):
kwargs = (f'a{i}=x' for i in range(self.N))
self.check_stack_size("f(" + ", ".join(kwargs) + ")")
def test_func_args(self):
self.check_stack_size("o.m(" + "x, " * self.N + ")")
def test_meth_kwargs(self):
kwargs = (f'a{i}=x' for i in range(self.N))
self.check_stack_size("o.m(" + ", ".join(kwargs) + ")")
def test_func_and(self):
code = "def f(x):\n"
code += " x and x\n" * self.N
self.check_stack_size(code)
class TestStackSizeStability(unittest.TestCase):
# Check that repeating certain snippets doesn't increase the stack size
# beyond what a single snippet requires.
def check_stack_size(self, snippet, async_=False):
def compile_snippet(i):
ns = {}
script = """def func():\n""" + i * snippet
if async_:
script = "async " + script
code = compile(script, "<script>", "exec")
exec(code, ns, ns)
return ns['func'].__code__
sizes = [compile_snippet(i).co_stacksize for i in range(2, 5)]
if len(set(sizes)) != 1:
import dis, io
out = io.StringIO()
dis.dis(compile_snippet(1), file=out)
self.fail("stack sizes diverge with # of consecutive snippets: "
"%s\n%s\n%s" % (sizes, snippet, out.getvalue()))
def test_if(self):
snippet = """
if x:
a
"""
self.check_stack_size(snippet)
def test_if_else(self):
snippet = """
if x:
a
elif y:
b
else:
c
"""
self.check_stack_size(snippet)
def test_try_except_bare(self):
snippet = """
try:
a
except:
b
"""
self.check_stack_size(snippet)
def test_try_except_qualified(self):
snippet = """
try:
a
except ImportError:
b
except:
c
else:
d
"""
self.check_stack_size(snippet)
def test_try_except_as(self):
snippet = """
try:
a
except ImportError as e:
b
except:
c
else:
d
"""
self.check_stack_size(snippet)
def test_try_except_star_qualified(self):
snippet = """
try:
a
except* ImportError:
b
else:
c
"""
self.check_stack_size(snippet)
def test_try_except_star_as(self):
snippet = """
try:
a
except* ImportError as e:
b
else:
c
"""
self.check_stack_size(snippet)
def test_try_except_star_finally(self):
snippet = """
try:
a
except* A:
b
finally:
c
"""
self.check_stack_size(snippet)
def test_try_finally(self):
snippet = """
try:
a
finally:
b
"""
self.check_stack_size(snippet)
def test_with(self):
snippet = """
with x as y:
a
"""
self.check_stack_size(snippet)
def test_while_else(self):
snippet = """
while x:
a
else:
b
"""
self.check_stack_size(snippet)
def test_for(self):
snippet = """
for x in y:
a
"""
self.check_stack_size(snippet)
def test_for_else(self):
snippet = """
for x in y:
a
else:
b
"""
self.check_stack_size(snippet)
def test_for_break_continue(self):
snippet = """
for x in y:
if z:
break
elif u:
continue
else:
a
else:
b
"""
self.check_stack_size(snippet)
def test_for_break_continue_inside_try_finally_block(self):
snippet = """
for x in y:
try:
if z:
break
elif u:
continue
else:
a
finally:
f
else:
b
"""
self.check_stack_size(snippet)
def test_for_break_continue_inside_finally_block(self):
snippet = """
for x in y:
try:
t
finally:
if z:
break
elif u:
continue
else:
a
else:
b
"""
self.check_stack_size(snippet)
def test_for_break_continue_inside_except_block(self):
snippet = """
for x in y:
try:
t
except:
if z:
break
elif u:
continue
else:
a
else:
b
"""
self.check_stack_size(snippet)
def test_for_break_continue_inside_with_block(self):
snippet = """
for x in y:
with c:
if z:
break
elif u:
continue
else:
a
else:
b
"""
self.check_stack_size(snippet)
def test_return_inside_try_finally_block(self):
snippet = """
try:
if z:
return
else:
a
finally:
f
"""
self.check_stack_size(snippet)
def test_return_inside_finally_block(self):
snippet = """
try:
t
finally:
if z:
return
else:
a
"""
self.check_stack_size(snippet)
def test_return_inside_except_block(self):
snippet = """
try:
t
except:
if z:
return
else:
a
"""
self.check_stack_size(snippet)
def test_return_inside_with_block(self):
snippet = """
with c:
if z:
return
else:
a
"""
self.check_stack_size(snippet)
def test_async_with(self):
snippet = """
async with x as y:
a
"""
self.check_stack_size(snippet, async_=True)
def test_async_for(self):
snippet = """
async for x in y:
a
"""
self.check_stack_size(snippet, async_=True)
def test_async_for_else(self):
snippet = """
async for x in y:
a
else:
b
"""
self.check_stack_size(snippet, async_=True)
def test_for_break_continue_inside_async_with_block(self):
snippet = """
for x in y:
async with c:
if z:
break
elif u:
continue
else:
a
else:
b
"""
self.check_stack_size(snippet, async_=True)
def test_return_inside_async_with_block(self):
snippet = """
async with c:
if z:
return
else:
a
"""
self.check_stack_size(snippet, async_=True)
if __name__ == "__main__":
unittest.main()
| 34.496408 | 95 | 0.533211 | [
"MIT"
] | ScriptBox99/wagi-dotnet | examples/wagipython/wagi-python/opt/wasi-python/lib/python3.11/test/test_compile.py | 52,814 | Python |
# Python
import pytest
from unittest import mock
from contextlib import contextmanager
from awx.main.models import Credential, UnifiedJob
from awx.main.tests.factories import (
create_organization,
create_job_template,
create_instance,
create_instance_group,
create_notification_template,
create_survey_spec,
create_workflow_job_template,
)
from django.core.cache import cache
def pytest_addoption(parser):
parser.addoption("--genschema", action="store_true", default=False, help="execute schema validator")
def pytest_configure(config):
import sys
sys._called_from_test = True
def pytest_unconfigure(config):
import sys
del sys._called_from_test
@pytest.fixture
def mock_access():
@contextmanager
def access_given_class(TowerClass):
try:
mock_instance = mock.MagicMock(__name__='foobar')
MockAccess = mock.MagicMock(return_value=mock_instance)
the_patch = mock.patch.dict('awx.main.access.access_registry', {TowerClass: MockAccess}, clear=False)
the_patch.__enter__()
yield mock_instance
finally:
the_patch.__exit__()
return access_given_class
@pytest.fixture
def job_template_factory():
return create_job_template
@pytest.fixture
def organization_factory():
return create_organization
@pytest.fixture
def notification_template_factory():
return create_notification_template
@pytest.fixture
def survey_spec_factory():
return create_survey_spec
@pytest.fixture
def instance_factory():
return create_instance
@pytest.fixture
def instance_group_factory():
return create_instance_group
@pytest.fixture
def default_instance_group(instance_factory, instance_group_factory):
return create_instance_group("default", instances=[create_instance("hostA")])
@pytest.fixture
def controlplane_instance_group(instance_factory, instance_group_factory):
return create_instance_group("controlplane", instances=[create_instance("hostA")])
@pytest.fixture
def job_template_with_survey_passwords_factory(job_template_factory):
def rf(persisted):
"Returns job with linked JT survey with password survey questions"
objects = job_template_factory(
'jt',
organization='org1',
survey=[
{'variable': 'submitter_email', 'type': 'text', 'default': '[email protected]'},
{'variable': 'secret_key', 'default': '6kQngg3h8lgiSTvIEb21', 'type': 'password'},
{'variable': 'SSN', 'type': 'password'},
],
persisted=persisted,
)
return objects.job_template
return rf
@pytest.fixture
def job_with_secret_key_unit(job_with_secret_key_factory):
return job_with_secret_key_factory(persisted=False)
@pytest.fixture
def workflow_job_template_factory():
return create_workflow_job_template
@pytest.fixture
def job_template_with_survey_passwords_unit(job_template_with_survey_passwords_factory):
return job_template_with_survey_passwords_factory(persisted=False)
@pytest.fixture
def mock_cache():
class MockCache(object):
cache = {}
def get(self, key, default=None):
return self.cache.get(key, default)
def set(self, key, value, timeout=60):
self.cache[key] = value
def delete(self, key):
del self.cache[key]
return MockCache()
def pytest_runtest_teardown(item, nextitem):
# clear Django cache at the end of every test ran
# NOTE: this should not be memcache (as it is deprecated), nor should it be redis.
# This is a local test cache, so we want every test to start with an empty cache
cache.clear()
@pytest.fixture(scope='session', autouse=True)
def mock_external_credential_input_sources():
# Credential objects query their related input sources on initialization.
# We mock that behavior out of credentials by default unless we need to
# test it explicitly.
with mock.patch.object(Credential, 'dynamic_input_fields', new=[]) as _fixture:
yield _fixture
@pytest.fixture(scope='session', autouse=True)
def mock_has_unpartitioned_events():
# has_unpartitioned_events determines if there are any events still
# left in the old, unpartitioned job events table. In order to work,
# this method looks up when the partition migration occurred. When
# Django's unit tests run, however, there will be no record of the migration.
# We mock this out to circumvent the migration query.
with mock.patch.object(UnifiedJob, 'has_unpartitioned_events', new=False) as _fixture:
yield _fixture
@pytest.fixture(scope='session', autouse=True)
def mock_get_event_queryset_no_job_created():
"""
SQLite friendly since partitions aren't supported. Do not add the faked job_created field to the filter. If we do, it will result in an sql query for the
job_created field. That field does not actually exist in a non-partition scenario.
"""
def event_qs(self):
kwargs = {self.event_parent_key: self.id}
return self.event_class.objects.filter(**kwargs)
with mock.patch.object(UnifiedJob, 'get_event_queryset', lambda self: event_qs(self)) as _fixture:
yield _fixture
| 28.89071 | 157 | 0.723284 | [
"Apache-2.0"
] | AdamVB/awx | awx/main/tests/conftest.py | 5,287 | Python |
import pytest
from djcookie_demo_proj.users.models import User
from djcookie_demo_proj.users.tests.factories import UserFactory
@pytest.fixture(autouse=True)
def media_storage(settings, tmpdir):
settings.MEDIA_ROOT = tmpdir.strpath
@pytest.fixture
def user() -> User:
return UserFactory()
| 20.133333 | 64 | 0.791391 | [
"MIT"
] | muutttu/djcookie_demo_proj | djcookie_demo_proj/conftest.py | 302 | Python |
#!/usr/bin/env python3
import sys
import os
import re
import argparse
import requests
from bs4 import BeautifulSoup as bs
version=1.1
print("""\033[1;36m
╦ ╦╔═╗╔╗ ╦═╗╔═╗╔═╗╔╦╗╔═╗╦═╗
║║║║╣ ╠╩╗ ╠╦╝║╣ ╠═╣║║║║╣ ╠╦╝
╚╩╝╚═╝╚═╝────╩╚═╚═╝╩ ╩╩ ╩╚═╝╩╚═
🔗🔥🔗🔥🔗🔥🔗🔥🔗🔥🔗🔥🔗🔥🔗🔥
--> Coded by FEBIN 🛡️🌐
\033[1;39m""")
def febrev_fuzz(url):
import requests
os.system("clear")
feblist=open("admin-panel.txt","r+")
text=str(feblist.read())
adminpages=list(text.split())
feblist.close()
print(f"""
[\033[1;37m+\033[1;39m] STARTED CRAWLING TO FIND ADMIN PANEL OF URL : \033[1;34m{url}
""")
try:
if url.startswith("https://") or url.startswith("http://"):
url=url
else:
print("Error : INVALID URL ! URL must start with 'http://' or 'https://'")
exit()
if url.endswith("/"):
url=url
server=requests.get(url).headers.get('Server')
print(f"\033[1;37m SERVER Type >> {server}")
print("\n<----------------------------------------------------------------------------------->")
print(" ")
else:
url=f"{url}/"
server=requests.get(url).headers.get('Server')
print(f"\033[1;37mSERVER Type >> {server}")
print("\n<----------------------------------------------------------------------------------->")
print(" ")
for i in range(len(adminpages)):
reqresp=requests.get(f"{url}/{adminpages[i]}",timeout=10)
if reqresp.status_code == 200:
print(f"\033[1;39m FOUND ==> {url}{adminpages[i]} \033[1;34m")
elif reqresp.status_code == 302:
print("\033[1;39m FOUND 302 ==> {url}{adminpages[i]} \033[1;34m")
else:
pass
except requests.exceptions.ConnectionError:
print("[\033[1;31m-\033[1;39m] Connection to the Server Failed, May be invalid URL or bad Internet connection. Check Your Internet connection,URL and try again\n ")
except requests.exceptions.ReadTimeout:
print("\033[1;31m [\033[1;31m-\033[1;39m] Error : EXECUTION STOPPED DUE TO !TIMED OUT! ERROR, YOUR INTERNET MAY BE DISCONNECTED!!!....EXITTED")
print("\033[1;37m WEB_REAMER Execution Completed. \033[1;33m!HAPPY HACKING! \033[1;34m \n")
def sub_brute(domain,sublist):
if os.path.isfile(sublist):
print(f"[\033[1;37m+\033[1;39m] Subdomain wordlist {sublist} loaded -> OK")
print("")
pass
else:
print(f"[\033[1;31m-\033[1;39m] Wordlist {sublist} not found!!")
exit()
sub=open(sublist,"r+")
subs=sub.read().split("\n")
sub.close()
for host in subs:
try:
req=requests.get(f"http://{host}.{domain}")
print(f"\033[1;39m{host}.{domain} --> \033[1;37m{req.status_code}")
except requests.exceptions.ConnectionError:
pass
except UnicodeError:
pass
print("")
print("[\033[1;37m+\033[1;39m] Finshed!")
print("\033[1;37m WEB_REAMER Execution Completed. \033[1;33m!HAPPY HACKING! \033[1;34m \n")
def wordlistgen(url,filepath):
import requests
from bs4 import BeautifulSoup
print("")
try:
webpage=requests.get(url)
pagedata=webpage.text
soup=BeautifulSoup(pagedata,"html.parser")
except requests.exceptions.ConnectionError:
print("\033[1;31m[-] ERROR CONNECTING THE SERVER...")
exit()
for script in soup(["script","style"]):
script.extract()
text1=soup.get_text()
text=str(text1.strip())
feb=text.split()
iscount=feb.count('is')
wascount=feb.count('was')
arecount=feb.count('are')
forcount=feb.count('for')
thecount=feb.count('the')
ofcount=feb.count('of')
tocount=feb.count('to')
try:
isinit=0
while isinit<=iscount:
feb.remove('is')
isinit=isinit+1
wasinit=0
while wasinit<=wascount:
feb.remove('was')
wasinit=wasinit+1
areinit=0
while areinit<=arecount:
feb.remove('are')
areinit=areinit+1
forinit=0
while forinit<=forcount:
feb.remove('for')
forinit=forinit+1
theinit=0
while theinit<=thecount:
feb.remove('the')
theinit=theinit+1
ofinit=0
while ofinit<=ofcount:
feb.remove('of')
ofinit=ofinit+1
toinit=0
while toinit<=tocount:
feb.remove('to')
toinit=toinit+1
except ValueError:
pass
feb.sort()
for string in feb:
count=feb.count(string)
strinit=0
while strinit < count:
feb.remove(string)
strinit=strinit+1
feb.sort()
for i in range(len(feb)):
try:
file=open(filepath,"a+")
file.write("\n"+feb[i])
file.close()
except FileNotFoundError:
homedir=os.environ.get('HOME')
file=open(f"{homedir}/fr-wordlist.txt","a+")
file.write("\n"+feb[i])
file.close()
if os.path.isfile(filepath):
print("")
print(f"\033[1;39m[\033[1;37m+\033[1;39m]Wordlist {filepath} successfully witten")
else:
print("\033[1;31m[-]Sorry:Path not Found!! The Path You Specified Doesn't Exist")
print("So Saved the wordlist as fr-wordlist.txt in the HOME Directory of the current User.....")
print("\033[1;37m WEB_REAMER Execution Completed. \033[1;33m!HAPPY HACKING! \033[1;34m \n")
def word_analyze(url):
import requests
from bs4 import BeautifulSoup
print("")
try:
webpage=requests.get(url)
pagedata=webpage.text
soup=BeautifulSoup(pagedata,"html.parser")
except requests.exceptions.ConnectionError:
print("\033[1;31m[\033[1;31m-\033[1;39m] ERROR CONNECTING THE SERVER...")
exit()
for script in soup(["script","style"]):
script.extract()
text1=soup.get_text()
text=str(text1.strip())
feb=text.split()
iscount=feb.count('is')
wascount=feb.count('was')
arecount=feb.count('are')
forcount=feb.count('for')
thecount=feb.count('the')
ofcount=feb.count('of')
tocount=feb.count('to')
try:
isinit=0
while isinit<=iscount:
feb.remove('is')
isinit=isinit+1
wasinit=0
while wasinit<=wascount:
feb.remove('was')
wasinit=wasinit+1
areinit=0
while areinit<=arecount:
feb.remove('are')
areinit=areinit+1
forinit=0
while forinit<=forcount:
feb.remove('for')
forinit=forinit+1
theinit=0
while theinit<=thecount:
feb.remove('the')
theinit=theinit+1
ofinit=0
while ofinit<=ofcount:
feb.remove('of')
ofinit=ofinit+1
toinit=0
while toinit<=tocount:
feb.remove('to')
toinit=toinit+1
except ValueError:
pass
feb.sort()
print("\033[1;32m-"*74)
print("\033[1;32m| Words | count/frequency | Graph | ")
print("\033[1;32m-"*74)
for string in feb:
count=feb.count(string)
for i in range(count):
feb.remove(string)
print(f"\033[1;34m| {string + ' ' * (22 - len(string)) + '| '}{str(count) +' ' * (22 - len(str(count)))}| \033[1;32m{'█' * count} " )
print("\033[1;33m-"*74)
def endpoint_harvest(url):
print(f"[\033[1;37m+\033[1;39m] Collecting Endpoints / Links from the webpage {url}")
from bs4 import BeautifulSoup
print("")
try:
webpage=requests.get(url)
pagedata=webpage.text
soup=BeautifulSoup(pagedata,"html.parser")
except requests.exceptions.ConnectionError:
print("\033[1;31m[\033[1;31m-\033[1;39m] ERROR CONNECTING THE SERVER...")
exit()
endpoint_pattern1=re.compile('(?:href=")(.*?)"')
endpoint_pattern2=re.compile('(?:src=")(.*?)"')
endpoint1=endpoint_pattern1.findall(pagedata)
endpoint2=endpoint_pattern2.findall(pagedata)
for link in endpoint1:
print(link.replace("href=","").replace("'","").replace(">","").replace('"','').replace("</"," "))
for src in endpoint2:
print(src.replace("src=","").replace("'","").replace(">","").replace('"','').replace("</"," "))
print("")
print("[\033[1;37m+\033[1;39m] Finished!")
def param(url):
from bs4 import BeautifulSoup
print("")
try:
webpage=requests.get(url)
pagedata=webpage.text
soup=BeautifulSoup(pagedata,"html.parser")
except requests.exceptions.ConnectionError:
print("\033[1;31m[\033[1;31m-\033[1;39m] ERROR CONNECTING THE SERVER...")
exit()
params=soup.find_all("input")
print("[\033[1;37m+\033[1;39m] Extracting Parameters from the WebPage!\n")
for param in params:
print(param.get("name"))
print("[\033[1;37m+\033[1;39m] Finished!")
parser = argparse.ArgumentParser(description='Parse the domain, wordlist etc..')
parser.add_argument('-link',dest='link', action='store_true',help='Extract Endpoints from url!')
parser.add_argument('-admin',dest='admin', action='store_true',help='Find Admin Panel of the given URL !')
parser.add_argument('-sub',dest='sub', action='store_true',help='Subdomain brute force of the given domain !')
parser.add_argument('-param',dest='param', action='store_true',help='Find hidden parameters from the given URL !')
parser.add_argument('-wordlist',dest='wordlist', action='store_true',help='Create targeted wordlist from the given URL !')
parser.add_argument('-analyze',dest='analyze', action='store_true',help='Analyze words and their frequencies from the given URL !')
parser.add_argument('-u',"--url",dest='url', action='store',help='The URL of the webpage!')
parser.add_argument('-d',"--domain",dest='domain', action='store',help='The domain name for sub domain brute-force!')
parser.add_argument('-w',"--wordlist",dest='list', action='store',help='Extract Endpoints from url!')
parser.add_argument('-o',"--outfile",dest='outfile', action='store',help='Output file to save the generated wordlist!!')
parser.add_argument('-v',"--version",dest='version', action='store_true',help='Version / Update Check !')
args=parser.parse_args()
try:
if args.link and args.url:
if args.url.startswith("http://") or args.url.startswith("https://"):
endpoint_harvest(args.url)
else:
print("[\033[1;31m-\033[1;39m] Invalid URL !")
exit()
elif args.admin and args.url:
if args.url.startswith("http://") or args.url.startswith("https://"):
febrev_fuzz(args.url)
else:
print("[\033[1;31m-\033[1;39m] Invalid URL !")
exit()
elif args.sub and args.domain and args.list:
if args.domain.startswith("http://") or args.domain.startswith("https://"):
print("[\033[1;31m-\033[1;39m] Expected Domain name not URL!")
exit()
else:
sub_brute(args.domain,args.list)
elif args.wordlist and args.url and args.outfile:
if args.url.startswith("http://") or args.url.startswith("https://"):
wordlistgen(args.url,args.outfile)
else:
print("[\033[1;31m-\033[1;39m] Invalid URL !")
exit()
elif args.analyze and args.url:
if args.url.startswith("http://") or args.url.startswith("https://"):
word_analyze(args.url)
else:
print("[\033[1;31m-\033[1;39m] Invalid URL !")
exit()
elif args.param and args.url:
if args.url.startswith("http://") or args.url.startswith("https://"):
param(args.url)
else:
print("[\033[1;31m-\033[1;39m] Invalid URL !")
exit()
elif args.version:
print(f"CURRENT VERSION : {version}")
try:
verq=requests.get("http://raw.githubusercontent.com/febinrev/web_reamer/master/version")
ver=float(verq.text.split()[0])
if ver > version:
print(f"[\033[1;37m+\033[1;39m] New Version {ver} of WEB_REAMER is available : https://github.com/febinrev/web_reamer.git")
else:
print("[\033[1;37m+\033[1;39m] WEB_REAMER is up-to-date!")
except requests.exceptions.ConnectionError:
print("[\033[1;31m-\033[1;39m] Error Connecting github !")
else:
print("""\033[1;33m
Usage:
\033[1;32m1. Endpoint / Link Extraction:
\033[1;39m ./web_reamer.py -link -u http://sample.com/ \033[1;32m
2. Admin Panel fuzzing:
\033[1;39m ./web_reamer.py -admin -u http://sample.com/ \033[1;32m
3. Subdomain Brute Force:
\033[1;39m ./web_reamer.py -sub -d sample.com -w subdomains.txt \033[1;32m
4. Find hidden parameters from webpage:
\033[1;39m ./web_reamer.py -param -u http://sample.com/ \033[1;32m
5. Create Targetted Wordlist from webpage:
\033[1;39m ./web_reamer.py -wordlist -u http://sample.com/ -o outfile_wordlist.txt \033[1;32m
6. Analyze Word frequencies from the WebPage :
\033[1;39m ./web_reamer.py -analyze -u http://sample.com/ \033[1;32m
7. Help :
\033[1;39m ./web_reamer.py -h \033[1;32m
\033[1;39m ./web_reamer.py --help \033[1;32m
8. Version / Update Check :
\033[1;39m ./web_reamer.py -v \033[1;32m
\033[1;39m ./web_reamer.py --version \033[1;32m
""")
except KeyboardInterrupt:
print("\n\033[1;39m[\033[1;31m-\033[1;39m] User Interruption! Exit!")
exit()
| 31.816976 | 166 | 0.656857 | [
"MIT"
] | febinrev/web_reamer | web_reamer.py | 12,209 | Python |
from prettytable import PrettyTable
from collections import OrderedDict
def _fieldnames(rows):
def g():
for row in rows:
yield from row
d = OrderedDict((k, None) for k in g())
return list(d.keys())
def _echo_table(rows):
if not rows: return
fieldnames = _fieldnames(rows)
table = PrettyTable(fieldnames)
table.align = 'l'
for row in rows:
table.add_row([row[k] or '' for k in fieldnames])
click.echo(table.get_string())
def _echo_row(row):
if not row: return
table = PrettyTable(row.keys())
table.align = 'l'
table.add_row(row.values())
click.echo(table.get_string())
def _echo_item(x):
if not x: return
click.echo(x)
import os
import logging
import click
import click_log
from . import config
_logger = logging.getLogger(__name__)
click_log.basic_config(_logger)
@click.group()
def cli():
pass
from . import blackboard
@cli.group(name='blackboard')
def cli_blackboard():
pass
@cli_blackboard.command(name='download', help='Download')
@click.option('--get-password', default=None, help='Command to evaluate to get password (default is to ask).')
@click.option('--netid', default=None, help='Use this NetID.')
@click.argument('link_text', type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_blackboard_download(netid, get_password, link_text):
if netid is None: netid = config.NETID
if get_password is None: get_password = config.get_password
x = blackboard.download(netid=netid, get_password=get_password, link_text=link_text)
_echo_item(x)
@cli_blackboard.command(name='upload', help='Upload')
@click.option('--get-password', default=None, help='Command to evaluate to get password (default is to ask).')
@click.option('--netid', default=None, help='Use this NetID.')
@click.argument('link_text', type=click.STRING)
@click.argument('path', type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_blackboard_upload(netid, get_password, link_text, path):
if netid is None: netid = config.NETID
if get_password is None: get_password = config.get_password
blackboard.upload(netid=netid, get_password=get_password, link_text=link_text, path=path)
@cli_blackboard.command(name='webassign', help='WebAssign')
@click.option('--get-password', default=None, help='Command to evaluate to get password (default is to ask).')
@click.option('--netid', default=None, help='Use this NetID.')
@click.argument('link_text', type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_blackboard_webassign(netid, get_password, link_text):
if netid is None: netid = config.NETID
if get_password is None: get_password = config.get_password
blackboard.webassign(netid=netid, get_password=get_password, link_text=link_text)
@cli_blackboard.command(name='combo', help='Combine the other commands')
@click.option('--get-password', default=None, help='Command to evaluate to get password (default is to ask).')
@click.option('--netid', default=None, help='Use this NetID.')
@click.option('--upload', type=click.Path(exists=True), default=None, help="CSV to upload.")
@click.option('--webassign/--no-webassign', default=False, help="Export/import WebAssign.")
@click.option('--download/--no-download', default=True, help="Download CSV.")
@click.argument('link_text', type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_blackboard_webassign(netid, get_password, link_text, upload, webassign, download):
if netid is None: netid = config.NETID
if get_password is None: get_password = config.get_password
if not (upload is None):
blackboard.upload(netid=netid, get_password=get_password, link_text=link_text, path=upload)
if webassign:
blackboard.webassign(netid=netid, get_password=get_password, link_text=link_text)
if download:
x = blackboard.download(netid=netid, get_password=get_password, link_text=link_text)
_echo_item(x)
from . import ldap
@cli.group(name='ldap')
def cli_ldap():
pass
@cli_ldap.command(name='filter', help='LDAP search with user-specified filter.')
@click.argument('filter', type=click.STRING)
@click.argument('keys', nargs=-1, type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_ldap_filter(filter, keys):
rows = list(ldap.filter(filter), list(keys))
_echo_table(rows)
@cli_ldap.command(name='search', help='Perform an LDAP search with filter: .' + ldap.SEARCH_FILTER)
@click.argument('term', type=click.STRING)
@click.argument('keys', nargs=-1, type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_ldap_search(term, keys):
rows = list(ldap.search(term, list(keys)))
_echo_table(rows)
@cli_ldap.command(name='netid', help='Filter by NetID')
@click.argument('netid', type=click.STRING)
@click.argument('keys', nargs=-1, type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_ldap_netid(netid, keys):
row = ldap.netid(netid, list(keys))
_echo_row(row)
@cli_ldap.command(name='alias', help='Filter by alias/PEA')
@click.argument('alias', type=click.STRING)
@click.argument('keys', nargs=-1, type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_ldap_alias(alias, keys):
row = ldap.alias(alias, list(keys))
_echo_row(row)
@cli_ldap.command(name='netid-to-alias', help='NetID -> alias/PEA')
@click.argument('netid', type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_ldap_netid_to_alias(netid):
x = ldap.netid_to_alias(netid)
_echo_item(x)
@cli_ldap.command(name='alias-to-netid', help='alias -> NetID')
@click.argument('alias', type=click.STRING)
@click_log.simple_verbosity_option(_logger)
def cli_ldap_alias_to_netid(alias):
x = ldap.alias_to_netid(alias)
_echo_item(x)
import os
import shutil
from . import coursebook
@cli.group(name='coursebook')
def cli_coursebook():
pass
@cli_coursebook.group(name='db')
def cli_coursebook_db():
pass
@cli_coursebook_db.command(name='update')
def cli_coursebook_db_update():
coursebook.db_update()
@cli_coursebook_db.command(name='netid-to-address')
@click.argument('netid', type=click.STRING)
def cli_coursebook_db_netid_to_address(netid):
X = list(coursebook.db_netid_to_address(netid))
_echo_item(' '.join(X))
@cli_coursebook.group(name='roster')
def cli_coursebook_roster():
pass
@cli_coursebook_roster.command(name='xlsx-to-csv', help='Convert a CourseBook roster XLSX to CSV.')
@click.option('--force/--no-force', default=False, help="Overwrite existing file.")
@click.argument('source', type=click.Path(exists=True))
@click.argument('target', type=click.Path())
def cli_coursebook_xlsx_to_csv(force, source, target):
if os.path.exists(target) and not force:
raise click.ClickException('File exists, maybe use --force?: ' + target)
coursebook.roster_xlsx_to_csv(source, target)
@cli_coursebook_roster.group(name='download')
def cli_coursebook_roster_download():
pass
@cli_coursebook_roster.command(name='download', help='Download a CourseBook roster.')
@click.option('--force/--no-force', default=False, help="Overwrite existing file.")
@click.option('--new/--no-new', default=False, help="Get a new file (don't use the cache).")
@click.option('--get-password', default=None, help='Command to evaluate to get password (default is to ask).')
@click.option('--netid', default=None, help='Use this NetID.')
@click.argument('address', nargs=-1, type=click.STRING)
def cli_coursebook_roster_download(netid, get_password, new, force, address):
def _split(x):
y, f = os.path.splitext(x)
return y, f[1:]
for x in address:
_, f = _split(x)
if not (f in coursebook.ROSTER_FORMAT):
raise click.ClickException("{x}: I don't know how to download a `{f}`, only: {these}.".format(x=x, f=f, these=' '.join(coursebook.ROSTER_FORMAT)))
# FIXME: check for proper address format
if os.path.exists(x) and not force:
raise click.ClickException('File exists, maybe use --force?: ' + x)
if netid is None: netid = config.NETID
if get_password is None: get_password = config.get_password
if netid is None:
raise click.ClickException('You must either specify a NetID in {config} or with --netid.'.format(config.CONFIG_FILE))
for x in address:
y, f = _split(x)
z = coursebook.roster_download(netid=netid, get_password=get_password, address=y, format=f, new=new)
shutil.copyfile(z, x)
| 34.108 | 158 | 0.72546 | [
"MIT"
] | bmccary/utd | utd/script.py | 8,527 | Python |
""" Argparse utilities"""
import sys
from six import PY2
from argparse import ArgumentParser
try:
from argparse import _SubParsersAction
except ImportError:
_SubParsersAction = type(None)
class PatchArgumentParser:
_original_parse_args = None
_original_parse_known_args = None
_original_add_subparsers = None
_add_subparsers_counter = 0
_current_task = None
_calling_current_task = False
_last_parsed_args = None
_last_arg_parser = None
@staticmethod
def add_subparsers(self, **kwargs):
if 'dest' not in kwargs:
if kwargs.get('title'):
kwargs['dest'] = '/' + kwargs['title']
else:
PatchArgumentParser._add_subparsers_counter += 1
kwargs['dest'] = '/subparser%d' % PatchArgumentParser._add_subparsers_counter
return PatchArgumentParser._original_add_subparsers(self, **kwargs)
@staticmethod
def parse_args(self, args=None, namespace=None):
return PatchArgumentParser._patched_parse_args(PatchArgumentParser._original_parse_args,
self, args=args, namespace=namespace)
@staticmethod
def parse_known_args(self, args=None, namespace=None):
return PatchArgumentParser._patched_parse_args(PatchArgumentParser._original_parse_known_args,
self, args=args, namespace=namespace)
@staticmethod
def _patched_parse_args(original_parse_fn, self, args=None, namespace=None):
current_task = PatchArgumentParser._current_task
# if we are running remotely, we always have a task id, so we better patch the argparser as soon as possible.
if not current_task:
from ..config import running_remotely, get_remote_task_id
if running_remotely():
# this will cause the current_task() to set PatchArgumentParser._current_task
from trains import Task
# noinspection PyBroadException
try:
current_task = Task.get_task(task_id=get_remote_task_id())
except Exception:
pass
# automatically connect to current task:
if current_task:
from ..config import running_remotely
if PatchArgumentParser._calling_current_task:
# if we are here and running remotely by now we should try to parse the arguments
if original_parse_fn:
PatchArgumentParser._add_last_parsed_args(original_parse_fn(self, args=args, namespace=namespace))
return PatchArgumentParser._last_parsed_args[-1]
PatchArgumentParser._calling_current_task = True
# Store last instance and result
PatchArgumentParser._add_last_arg_parser(self)
parsed_args = None
# parse if we are running in dev mode
if not running_remotely() and original_parse_fn:
parsed_args = original_parse_fn(self, args=args, namespace=namespace)
PatchArgumentParser._add_last_parsed_args(parsed_args)
# noinspection PyBroadException
try:
# sync to/from task
# noinspection PyProtectedMember
current_task._connect_argparse(
self, args=args, namespace=namespace,
parsed_args=parsed_args[0] if isinstance(parsed_args, tuple) else parsed_args
)
except Exception:
pass
# sync back and parse
if running_remotely() and original_parse_fn:
# if we are running python2 check if we have subparsers,
# if we do we need to patch the args, because there is no default subparser
if PY2:
import itertools
def _get_sub_parsers_defaults(subparser, prev=[]):
actions_grp = [a._actions for a in subparser.choices.values()] if isinstance(
subparser, _SubParsersAction) else [subparser._actions]
sub_parsers_defaults = [[subparser]] if hasattr(
subparser, 'default') and subparser.default else []
for actions in actions_grp:
sub_parsers_defaults += [_get_sub_parsers_defaults(a, prev)
for a in actions if isinstance(a, _SubParsersAction) and
hasattr(a, 'default') and a.default]
return list(itertools.chain.from_iterable(sub_parsers_defaults))
sub_parsers_defaults = _get_sub_parsers_defaults(self)
if sub_parsers_defaults:
if args is None:
# args default to the system args
import sys as _sys
args = _sys.argv[1:]
else:
args = list(args)
# make sure we append the subparsers
for a in sub_parsers_defaults:
if a.default not in args:
args.append(a.default)
PatchArgumentParser._add_last_parsed_args(original_parse_fn(self, args=args, namespace=namespace))
else:
PatchArgumentParser._add_last_parsed_args(parsed_args or {})
PatchArgumentParser._calling_current_task = False
return PatchArgumentParser._last_parsed_args[-1]
# Store last instance and result
PatchArgumentParser._add_last_arg_parser(self)
PatchArgumentParser._add_last_parsed_args(
{} if not original_parse_fn else original_parse_fn(self, args=args, namespace=namespace))
return PatchArgumentParser._last_parsed_args[-1]
@staticmethod
def _add_last_parsed_args(parsed_args):
PatchArgumentParser._last_parsed_args = (PatchArgumentParser._last_parsed_args or []) + [parsed_args]
@staticmethod
def _add_last_arg_parser(a_argparser):
PatchArgumentParser._last_arg_parser = (PatchArgumentParser._last_arg_parser or []) + [a_argparser]
def patch_argparse():
# make sure we only patch once
if not sys.modules.get('argparse') or hasattr(sys.modules['argparse'].ArgumentParser, '_parse_args_patched'):
return
# mark patched argparse
sys.modules['argparse'].ArgumentParser._parse_args_patched = True
# patch argparser
PatchArgumentParser._original_parse_args = sys.modules['argparse'].ArgumentParser.parse_args
PatchArgumentParser._original_parse_known_args = sys.modules['argparse'].ArgumentParser.parse_known_args
PatchArgumentParser._original_add_subparsers = sys.modules['argparse'].ArgumentParser.add_subparsers
sys.modules['argparse'].ArgumentParser.parse_args = PatchArgumentParser.parse_args
sys.modules['argparse'].ArgumentParser.parse_known_args = PatchArgumentParser.parse_known_args
sys.modules['argparse'].ArgumentParser.add_subparsers = PatchArgumentParser.add_subparsers
# Notice! we are patching argparser, sop we know if someone parsed arguments before connecting to task
patch_argparse()
def call_original_argparser(self, args=None, namespace=None):
if PatchArgumentParser._original_parse_args:
return PatchArgumentParser._original_parse_args(self, args=args, namespace=namespace)
def argparser_parseargs_called():
return PatchArgumentParser._last_arg_parser is not None
def argparser_update_currenttask(task):
PatchArgumentParser._current_task = task
def get_argparser_last_args():
if not PatchArgumentParser._last_arg_parser or not PatchArgumentParser._last_parsed_args:
return []
return [(parser, args[0] if isinstance(args, tuple) else args)
for parser, args in zip(PatchArgumentParser._last_arg_parser, PatchArgumentParser._last_parsed_args)]
def add_params_to_parser(parser, params):
assert isinstance(parser, ArgumentParser)
assert isinstance(params, dict)
def get_type_details(v):
for t in (int, float, str):
try:
value = t(v)
return t, value
except ValueError:
continue
# AJB temporary protection from ui problems sending empty dicts
params.pop('', None)
for param, value in params.items():
type, type_value = get_type_details(value)
parser.add_argument('--%s' % param, type=type, default=type_value)
return parser
| 44.147208 | 118 | 0.64505 | [
"Apache-2.0"
] | nadeemshaikh-github/trains | trains/utilities/args.py | 8,697 | Python |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Apr, 2019
@author: Nathan de Lara <[email protected]>
"""
from typing import Optional, Union
import numpy as np
from sknetwork.utils.check import check_seeds
def stack_seeds(n_row: int, n_col: int, seeds_row: Optional[Union[np.ndarray, dict]],
seeds_col: Optional[Union[np.ndarray, dict]] = None, default_value: float = -1) -> np.ndarray:
"""Process seeds for rows and columns and stack the results into a single vector."""
if seeds_row is None and seeds_col is None:
seeds_row = np.ones(n_row)
seeds_col = default_value * np.ones(n_col)
elif seeds_row is None:
seeds_row = default_value * np.ones(n_row)
elif seeds_col is None:
seeds_col = default_value * np.ones(n_col)
seeds_row = check_seeds(seeds_row, n_row)
seeds_col = check_seeds(seeds_col, n_col)
return np.hstack((seeds_row, seeds_col))
def seeds2probs(n: int, seeds: Union[dict, np.ndarray] = None) -> np.ndarray:
"""Transform seeds into probability vector.
Parameters
----------
n : int
Total number of samples.
seeds :
If ``None``, the uniform distribution is used.
Otherwise, a non-negative, non-zero vector or a dictionary must be provided.
Returns
-------
probs: np.ndarray
A probability vector.
"""
if seeds is None:
return np.ones(n) / n
else:
seeds = check_seeds(seeds, n)
probs = np.zeros_like(seeds, dtype=float)
ix = (seeds > 0)
probs[ix] = seeds[ix]
w: float = probs.sum()
if w > 0:
return probs / w
else:
raise ValueError('At least one seeds must have a positive probability.')
| 30.877193 | 110 | 0.628409 | [
"BSD-3-Clause"
] | JulienSim001/scikit-network | sknetwork/utils/seeds.py | 1,760 | Python |
""" This module provides the unsafe things for targets/numbers.py
"""
from .. import types
from ..extending import intrinsic
from llvmlite import ir
@intrinsic
def viewer(tyctx, val, viewty):
""" Bitcast a scalar 'val' to the given type 'viewty'. """
bits = val.bitwidth
if isinstance(viewty.dtype, types.Integer):
bitcastty = ir.IntType(bits)
elif isinstance(viewty.dtype, types.Float):
bitcastty = ir.FloatType() if bits == 32 else ir.DoubleType()
else:
assert 0, "unreachable"
def codegen(cgctx, builder, typ, args):
flt = args[0]
return builder.bitcast(flt, bitcastty)
retty = viewty.dtype
sig = retty(val, viewty)
return sig, codegen
@intrinsic
def trailing_zeros(typeingctx, src):
"""Counts trailing zeros in the binary representation of an integer."""
if not isinstance(src, types.Integer):
raise TypeError(
"trailing_zeros is only defined for integers, but passed value was"
" '{}'.".format(src)
)
def codegen(context, builder, signature, args):
[src] = args
return builder.cttz(src, ir.Constant(ir.IntType(1), 0))
return src(src), codegen
@intrinsic
def leading_zeros(typeingctx, src):
"""Counts leading zeros in the binary representation of an integer."""
if not isinstance(src, types.Integer):
raise TypeError(
"leading_zeros is only defined for integers, but passed value was "
"'{}'.".format(src)
)
def codegen(context, builder, signature, args):
[src] = args
return builder.ctlz(src, ir.Constant(ir.IntType(1), 0))
return src(src), codegen
| 30.071429 | 79 | 0.643705 | [
"BSD-2-Clause",
"Apache-2.0"
] | Hardcode84/numba | numba/unsafe/numbers.py | 1,684 | Python |
# -*- coding: utf-8 -*-
"""
Created on Sat Aug 3 23:07:15 2019
@author: ydima
"""
import logging
import os
from pathlib import Path
import random
import shlex
import string
from subprocess import PIPE, Popen
import tempfile
from typing import Dict, List, Optional, Union
import pandas as pd
from .constants import (
DIRECTIONS,
IN,
IS_WIN32,
NEWLINE,
OUT,
QUERY,
QUERYOUT,
SQLCHAR,
TABLE,
VIEW,
BCPandasException,
BCPandasValueError,
read_data_settings,
sql_collation,
)
logger = logging.getLogger(__name__)
def bcp(
sql_item: str,
direction: str,
flat_file: str,
creds,
sql_type: str = "table",
schema: str = "dbo",
format_file_path: str = None,
batch_size: int = None,
col_delimiter: str = None,
row_terminator: str = None,
bcp_path: Union[str, Path] = None,
error_file_path: str = None
):
"""
See https://docs.microsoft.com/en-us/sql/tools/bcp-utility
"""
combos = {TABLE: [IN, OUT], QUERY: [QUERYOUT], VIEW: [IN, OUT]}
direc = direction.lower()
# validation
if direc not in DIRECTIONS:
raise BCPandasValueError(
f"Param 'direction' must be one of {DIRECTIONS}, you passed {direc}"
)
if direc not in combos[sql_type]:
raise BCPandasValueError(
f"Wrong combo of direction and SQL object, you passed {sql_type} and {direc} ."
)
# auth
if creds.with_krb_auth:
auth = ["-T"]
else:
auth = ["-U", creds.username, "-P", creds.password]
# prepare SQL item string
if sql_type == QUERY:
# remove newlines for queries, otherwise messes up BCP
sql_item_string = quote_this("".join(sql_item.splitlines()))
else:
sql_item_string = f"{schema}.{sql_item}"
# construct BCP command
bcp_command = [
"bcp" if bcp_path is None else quote_this(str(bcp_path)),
sql_item_string,
direc,
flat_file,
"-S",
creds.server,
"-d",
creds.database,
"-q", # Executes the SET QUOTED_IDENTIFIERS ON statement, needed for Azure SQL DW
"-e",
error_file_path
] + auth
if batch_size:
bcp_command += ["-b", str(batch_size)]
# formats
if direc == IN:
bcp_command += ["-f", format_file_path]
elif direc in (OUT, QUERYOUT):
bcp_command += [
"-c", # marking as character data, not Unicode (maybe make as param?)
quote_this(
f"-t{read_data_settings['delimiter'] if col_delimiter is None else col_delimiter}"
),
quote_this(
f"-r{read_data_settings['newline'] if row_terminator is None else row_terminator}"
),
]
# execute
bcp_command_log = [c if c != creds.password else "[REDACTED]" for c in bcp_command]
logger.info(f"Executing BCP command now... \nBCP command is: {bcp_command_log}")
ret_code = run_cmd(bcp_command)
if ret_code:
raise BCPandasException(f"Bcp command failed with exit code {ret_code}")
def get_temp_file() -> str:
"""
Returns full path to a temporary file without creating it.
"""
tmp_dir = tempfile.gettempdir()
file_path = os.path.join(
tmp_dir, "".join(random.choices(string.ascii_letters + string.digits, k=21))
)
return file_path
def _escape(input_string: str) -> str:
"""
Adopted from https://github.com/titan550/bcpy/blob/master/bcpy/format_file_builder.py#L25
"""
return (
input_string.replace('"', '\\"')
.replace("'", "\\'")
.replace("\r", "\\r")
.replace("\n", "\\n")
)
def build_format_file(
df: pd.DataFrame, delimiter: str, db_cols_order: Optional[Dict[str, int]] = None
) -> str:
"""
Creates the non-xml SQL format file. Puts 4 spaces between each section.
See https://docs.microsoft.com/en-us/sql/relational-databases/import-export/non-xml-format-files-sql-server
for the specification of the file.
# TODO add params/options to control:
# - the char type (not just SQLCHAR),
Parameters
----------
df : pandas DataFrame
delimiter : a valid delimiter character
db_cols_order : dict, optional
Dict of {database column name -> ordinal position of the column}.
Maps existing columns in the database to their ordinal position, i.e. the order of the columns in the db table.
1-indexed, so the first columns is 1, second is 2, etc.
Only needed if the order of the columns in the dataframe doesn't match the database.
Returns
-------
A string containing the format file
"""
_space = " " * 4
format_file_str = f"9.0\n{len(df.columns)}\n" # Version and Number of columns
for col_num, col_name in enumerate(df.columns, start=1):
# last col gets a newline sep
_delim = delimiter if col_num != len(df.columns) else NEWLINE
_line = _space.join(
[
str(col_num), # Host file field order
SQLCHAR, # Host file data type
str(0), # Prefix length
str(0), # Host file data length
f'"{_escape(_delim)}"', # Terminator (see note below)
str(
col_num if not db_cols_order else db_cols_order[str(col_name)]
), # Server column order
str(col_name), # Server column name, optional as long as not blank
sql_collation, # Column collation
"\n",
]
)
format_file_str += _line
# FYI very important to surround the Terminator with quotes, otherwise BCP fails with:
# "Unexpected EOF encountered in BCP data-file". Hugely frustrating bug.
return format_file_str
def quote_this(this: str, skip: bool = False) -> str:
"""
OS-safe way to quote a string.
Returns the string with quotes around it.
On Windows ~~it's double quotes~~ we skip quoting,
on Linux it's single quotes.
"""
if isinstance(this, str):
if IS_WIN32:
return this # TODO maybe change?
else:
return shlex.quote(this)
else:
return this
def run_cmd(cmd: List[str]) -> int:
"""
Runs the given command.
Prints STDOUT in real time, prints STDERR when command is complete,
and logs both STDOUT and STDERR.
Paramters
---------
cmd : list of str
The command to run, to be submitted to `subprocess.Popen()`
Returns
-------
The exit code of the command
"""
if IS_WIN32:
with_shell = False
else:
with_shell = True
cmd = " ".join(cmd) # type: ignore
proc = Popen(cmd, stdout=PIPE, stderr=PIPE, encoding="utf-8", errors="utf-8", shell=with_shell,)
# live stream STDOUT
while True:
outs = proc.stdout.readline()
if outs:
print(outs, end="")
logger.info(outs)
if proc.poll() is not None and outs == "":
break
errs = proc.stderr.readlines()
if errs:
print(errs, end="")
logger.error(errs)
return proc.returncode
| 29.048387 | 119 | 0.600222 | [
"MIT"
] | alon-r/bcpandas | bcpandas/utils.py | 7,204 | Python |
_base_ = [
'../_base_/datasets/coco_detection.py',
'../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py',
'../_base_/swa.py'
]
# model settings
model = dict(
type='ATSS',
pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224_22k.pth',
backbone=dict(
type='SwinTransformer',
embed_dim=128,
depths=[2, 2, 18, 2],
num_heads=[4, 8, 16, 32],
window_size=7,
mlp_ratio=4.,
qkv_bias=True,
qk_scale=None,
drop_rate=0.,
attn_drop_rate=0.,
ape=False,
drop_path_rate=0.3,
patch_norm=True,
out_indices=(0, 1, 2, 3),
use_checkpoint=True,
),
neck=dict(
type='PAFPNX',
in_channels=[128, 256, 512, 1024],
out_channels=256,
start_level=1,
add_extra_convs='on_output',
num_outs=5,
relu_before_extra_convs=True,
pafpn_conv_cfg=dict(type='DCNv2'),
norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)),
bbox_head=dict(
type='DDODHead',
num_classes=1,
in_channels=256,
stacked_convs=4,
feat_channels=256,
anchor_generator=dict(
type='AnchorGenerator',
ratios=[1.0],
octave_base_scale=8,
scales_per_octave=1,
strides=[8, 16, 32, 64, 128]),
bbox_coder=dict(
type='DeltaXYWHBBoxCoder',
target_means=[.0, .0, .0, .0],
target_stds=[0.1, 0.1, 0.2, 0.2]),
loss_cls=dict(type='FocalLoss', use_sigmoid=True, gamma=2.0, alpha=0.25, loss_weight=1.0),
loss_bbox=dict(type='CIoULoss', loss_weight=2.0),
loss_iou=dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
# training and testing settings
train_cfg=dict(
assigner=dict(type='ATSSCostAssigner', topk=9),
reg_assigner=dict(type='ATSSCostAssigner', topk=9, alpha=0.5),
allowed_border=-1,
pos_weight=-1,
debug=False),
test_cfg=dict(
nms_pre=1000,
min_bbox_size=0,
score_thr=0.05,
nms=dict(type='nms', iou_threshold=0.6),
max_per_img=100))
# data setting
dataset_type = 'CocoDataset'
data_root = '/content/data/'
img_norm_cfg = dict(mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
albu_train_transforms = [
dict(type='ShiftScaleRotate', shift_limit=0.0625, scale_limit=0.0, rotate_limit=0, interpolation=1, p=0.5),
dict(type='RandomBrightnessContrast', brightness_limit=[0.1, 0.3], contrast_limit=[0.1, 0.3], p=0.2),
dict(
type='OneOf',
transforms=[
dict(
type='RGBShift',
r_shift_limit=10,
g_shift_limit=10,
b_shift_limit=10,
p=1.0),
dict(
type='HueSaturationValue',
hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=1.0)
],
p=0.1),
dict(type='ImageCompression', quality_lower=85, quality_upper=95, p=0.2),
dict(type='ChannelShuffle', p=0.1),
dict(
type='OneOf',
transforms=[
dict(type='Blur', blur_limit=3, p=1.0),
dict(type='MedianBlur', blur_limit=3, p=1.0)
],
p=0.1),
]
train_pipeline = [
dict(type='LoadImageFromFile'),
dict(type='LoadAnnotations', with_bbox=True),
dict(
type='RandomCrop',
crop_type='relative_range',
crop_size=(0.9, 0.9),
allow_negative_crop = False),
dict(
type='Resize',
img_scale=[(720, 720), (960, 960)],
multiscale_mode='range',
keep_ratio=True),
dict(
type='CutOut',
n_holes=(5, 10),
cutout_shape=[(4, 4), (4, 8), (8, 4), (8, 8),
(16, 8), (8, 16), (16, 16), (16, 32), (32, 16), (32, 32),
(32, 48), (48, 32), (48, 48)]),
dict(type='RandomFlip', flip_ratio=0.5),
dict(type='Pad', size_divisor=32),
dict(
type='Albu',
transforms=albu_train_transforms,
bbox_params=dict(
type='BboxParams',
format='pascal_voc',
label_fields=['gt_labels'],
min_visibility=0.0,
filter_lost_elements=True),
keymap={
'img': 'image',
'gt_bboxes': 'bboxes'
},
update_pad_shape=False,
skip_img_without_anno=True),
dict(type='Normalize', **img_norm_cfg),
dict(type='DefaultFormatBundle'),
dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
]
test_pipeline = [
dict(type='LoadImageFromFile'),
dict(
type='MultiScaleFlipAug',
img_scale=(800, 800),
flip=False,
transforms=[
dict(type='Resize', keep_ratio=True),
dict(type='RandomFlip'),
dict(type='Normalize', **img_norm_cfg),
dict(type='Pad', size_divisor=32),
dict(type='DefaultFormatBundle'),
dict(type='Collect', keys=['img']),
])
]
data = dict(
samples_per_gpu=12,
workers_per_gpu=4,
train=dict(type = dataset_type,
ann_file = data_root + '/annotations/instances_train2017.json',
img_prefix = 'train_images/',
pipeline=train_pipeline),
val=dict(type = dataset_type,
ann_file = data_root + '/annotations/instances_val2017.json',
img_prefix = 'val_images/',
pipeline=test_pipeline,
samples_per_gpu = 24),
test=dict(pipeline=test_pipeline))
# optimizer
optimizer = dict(_delete_=True, type='AdamW', lr=0.0001, betas = (0.9, 0.999), weight_decay=0.05)
optimizer_config = dict(grad_clip = None)
log_config = dict(interval = 10)
# learning policy
lr_config = dict(
policy='CosineAnnealing',
min_lr_ratio = 0.2,
warmup='linear',
warmup_iters=500,
warmup_ratio=0.1,
)
runner = dict(type='IterBasedRunner', max_iters=3000, max_epochs = None)
checkpoint_config = dict(interval = 100)
evaluation = dict(interval = 100, metric = 'bbox')
fp16 = dict(loss_scale=512.)
# runtime
load_from = '/gdrive/My Drive/checkpoints/bvr_atss_x101_dcn_fpn_2x_coco.pth'
resume_from = None
workflow = [('train', 1)]
| 26.984848 | 121 | 0.685944 | [
"Apache-2.0"
] | VietDunghacker/VarifocalNet | configs/ddod/swin.py | 5,343 | Python |
# 電子レンジ
def get_E_Elc_microwave_d_t(P_Elc_microwave_cook_rtd, t_microwave_cook_d_t):
"""時刻別消費電力量を計算する
Parameters
----------
P_Elc_microwave_cook_rtd : float
調理時の定格待機電力, W
t_microwave_cook_d_t : ndarray(N-dimensional array)
1年間の全時間の調理時間を格納したND配列, h
d日t時の調理時間が年開始時から8760個連続して格納されている
Returns
----------
E_Elc_microwave_d_t : ndarray(N-dimensional array)
1年間の全時間の消費電力量を格納したND配列, Wh
d日t時の消費電力量が年開始時から8760個連続して格納されている
"""
P_Elc_microwave_cook = get_P_Elc_microwave_cook(P_Elc_microwave_cook_rtd)
E_Elc_microwave_d_t = P_Elc_microwave_cook * t_microwave_cook_d_t
E_Elc_microwave_d_t = E_Elc_microwave_d_t * 10**(-3)
return E_Elc_microwave_d_t
def get_P_Elc_microwave_cook(P_Elc_microwave_rtd):
"""調理時の消費電力を計算する
Parameters
----------
P_Elc_microwave_cook_rtd : float
調理時の定格待機電力, W
Returns
----------
P_Elc_microwave_cook : float
調理時の消費電力, W
"""
P_Elc_microwave_cook = 0.9373 * P_Elc_microwave_rtd
return P_Elc_microwave_cook
| 22.74 | 77 | 0.664908 | [
"MIT"
] | jjj-design/pyhees | src/pyhees/section10_j1_f.py | 1,435 | Python |
import torch
import torch.nn as nn
from src.network import Conv2d
class MCNN(nn.Module):
def __init__(self, bn=False):
super(MCNN, self).__init__()
self.branch1 = nn.Sequential(Conv2d(1, 16, 9, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(16, 32, 7, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(32, 16, 7, same_padding=True, bn=bn),
Conv2d(16, 8, 7, same_padding=True, bn=bn))
self.branch2 = nn.Sequential(Conv2d(1, 20, 7, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(20, 40, 5, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(40, 20, 5, same_padding=True, bn=bn),
Conv2d(20, 10, 5, same_padding=True, bn=bn))
self.branch3 = nn.Sequential(Conv2d(1, 24, 5, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(24, 48, 3, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(48, 24, 3, same_padding=True, bn=bn),
Conv2d(24, 12, 3, same_padding=True, bn=bn))
self.branch4 = nn.Sequential(Conv2d(1, 28, 3, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(28, 56, 1, same_padding=True, bn=bn),
nn.MaxPool2d(2),
Conv2d(56, 28, 1, same_padding=True, bn=bn),
Conv2d(28, 14, 1, same_padding=True, bn=bn))
self.fuse = nn.Sequential(Conv2d(44, 1, 1, same_padding=True, bn=bn))
def forward(self, im_data):
x1 = self.branch1(im_data)
x2 = self.branch2(im_data)
x3 = self.branch3(im_data)
x4 = self.branch4(im_data)
x = torch.cat((x1, x2, x3, x4), 1)
x = self.fuse(x)
return x
| 45.77551 | 81 | 0.436469 | [
"MIT"
] | DhenryD/CrowdCount-mcnn | src/models.py | 2,243 | Python |
from ... import create_engine
from ... import exc
from ...engine import url as sa_url
from ...testing.provision import configure_follower
from ...testing.provision import create_db
from ...testing.provision import drop_db
from ...testing.provision import follower_url_from_main
from ...testing.provision import log
from ...testing.provision import run_reap_dbs
from ...testing.provision import temp_table_keyword_args
from ...testing.provision import update_db_opts
@create_db.for_db("oracle")
def _oracle_create_db(cfg, eng, ident):
# NOTE: make sure you've run "ALTER DATABASE default tablespace users" or
# similar, so that the default tablespace is not "system"; reflection will
# fail otherwise
with eng.connect() as conn:
conn.execute("create user %s identified by xe" % ident)
conn.execute("create user %s_ts1 identified by xe" % ident)
conn.execute("create user %s_ts2 identified by xe" % ident)
conn.execute("grant dba to %s" % (ident,))
conn.execute("grant unlimited tablespace to %s" % ident)
conn.execute("grant unlimited tablespace to %s_ts1" % ident)
conn.execute("grant unlimited tablespace to %s_ts2" % ident)
@configure_follower.for_db("oracle")
def _oracle_configure_follower(config, ident):
config.test_schema = "%s_ts1" % ident
config.test_schema_2 = "%s_ts2" % ident
def _ora_drop_ignore(conn, dbname):
try:
conn.execute("drop user %s cascade" % dbname)
log.info("Reaped db: %s", dbname)
return True
except exc.DatabaseError as err:
log.warning("couldn't drop db: %s", err)
return False
@drop_db.for_db("oracle")
def _oracle_drop_db(cfg, eng, ident):
with eng.connect() as conn:
# cx_Oracle seems to occasionally leak open connections when a large
# suite it run, even if we confirm we have zero references to
# connection objects.
# while there is a "kill session" command in Oracle,
# it unfortunately does not release the connection sufficiently.
_ora_drop_ignore(conn, ident)
_ora_drop_ignore(conn, "%s_ts1" % ident)
_ora_drop_ignore(conn, "%s_ts2" % ident)
@update_db_opts.for_db("oracle")
def _oracle_update_db_opts(db_url, db_opts):
pass
@run_reap_dbs.for_db("oracle")
def _reap_oracle_dbs(url, idents):
log.info("db reaper connecting to %r", url)
eng = create_engine(url)
with eng.connect() as conn:
log.info("identifiers in file: %s", ", ".join(idents))
to_reap = conn.execute(
"select u.username from all_users u where username "
"like 'TEST_%' and not exists (select username "
"from v$session where username=u.username)"
)
all_names = {username.lower() for (username,) in to_reap}
to_drop = set()
for name in all_names:
if name.endswith("_ts1") or name.endswith("_ts2"):
continue
elif name in idents:
to_drop.add(name)
if "%s_ts1" % name in all_names:
to_drop.add("%s_ts1" % name)
if "%s_ts2" % name in all_names:
to_drop.add("%s_ts2" % name)
dropped = total = 0
for total, username in enumerate(to_drop, 1):
if _ora_drop_ignore(conn, username):
dropped += 1
log.info(
"Dropped %d out of %d stale databases detected", dropped, total
)
@follower_url_from_main.for_db("oracle")
def _oracle_follower_url_from_main(url, ident):
url = sa_url.make_url(url)
url.username = ident
url.password = "xe"
return url
@temp_table_keyword_args.for_db("oracle")
def _oracle_temp_table_keyword_args(cfg, eng):
return {
"prefixes": ["GLOBAL TEMPORARY"],
"oracle_on_commit": "PRESERVE ROWS",
}
| 34.792793 | 78 | 0.651217 | [
"MIT"
] | 01king-ori/Kingsblog | virtual/lib/python3.7/site-packages/sqlalchemy/dialects/oracle/provision.py | 3,862 | Python |
from encapsulation_exercise.wild_cat_zoo.project.animal import Animal
class Cheetah(Animal):
MONEY_FOR_CARE = 60
def __init__(self, name, gender, age):
super().__init__(name, gender, age, self.MONEY_FOR_CARE) | 28.375 | 69 | 0.744493 | [
"MIT"
] | Veselin-Stoilov/software-university-OOP | encapsulation_exercise/wild_cat_zoo/project/cheetah.py | 227 | Python |
# -*- coding: utf-8 -*-
"""
pygments.lexers.other
~~~~~~~~~~~~~~~~~~~~~
Lexers for other languages.
:copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
import re
from pygments.lexer import Lexer, RegexLexer, include, bygroups, using, \
this, do_insertions
from pygments.token import Error, Punctuation, \
Text, Comment, Operator, Keyword, Name, String, Number, Generic
from pygments.util import shebang_matches
from pygments.lexers.web import HtmlLexer
__all__ = ['SqlLexer', 'MySqlLexer', 'SqliteConsoleLexer', 'BrainfuckLexer',
'BashLexer', 'BatchLexer', 'BefungeLexer', 'RedcodeLexer',
'MOOCodeLexer', 'SmalltalkLexer', 'TcshLexer', 'LogtalkLexer',
'GnuplotLexer', 'PovrayLexer', 'AppleScriptLexer',
'BashSessionLexer', 'ModelicaLexer', 'RebolLexer', 'ABAPLexer',
'NewspeakLexer', 'GherkinLexer', 'AsymptoteLexer']
line_re = re.compile('.*?\n')
class SqlLexer(RegexLexer):
"""
Lexer for Structured Query Language. Currently, this lexer does
not recognize any special syntax except ANSI SQL.
"""
name = 'SQL'
aliases = ['sql']
filenames = ['*.sql']
mimetypes = ['text/x-sql']
flags = re.IGNORECASE
tokens = {
'root': [
(r'\s+', Text),
(r'--.*?\n', Comment.Single),
(r'/\*', Comment.Multiline, 'multiline-comments'),
(r'(ABORT|ABS|ABSOLUTE|ACCESS|ADA|ADD|ADMIN|AFTER|AGGREGATE|'
r'ALIAS|ALL|ALLOCATE|ALTER|ANALYSE|ANALYZE|AND|ANY|ARE|AS|'
r'ASC|ASENSITIVE|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATOMIC|'
r'AUTHORIZATION|AVG|BACKWARD|BEFORE|BEGIN|BETWEEN|BITVAR|'
r'BIT_LENGTH|BOTH|BREADTH|BY|C|CACHE|CALL|CALLED|CARDINALITY|'
r'CASCADE|CASCADED|CASE|CAST|CATALOG|CATALOG_NAME|CHAIN|'
r'CHARACTERISTICS|CHARACTER_LENGTH|CHARACTER_SET_CATALOG|'
r'CHARACTER_SET_NAME|CHARACTER_SET_SCHEMA|CHAR_LENGTH|CHECK|'
r'CHECKED|CHECKPOINT|CLASS|CLASS_ORIGIN|CLOB|CLOSE|CLUSTER|'
r'COALSECE|COBOL|COLLATE|COLLATION|COLLATION_CATALOG|'
r'COLLATION_NAME|COLLATION_SCHEMA|COLUMN|COLUMN_NAME|'
r'COMMAND_FUNCTION|COMMAND_FUNCTION_CODE|COMMENT|COMMIT|'
r'COMMITTED|COMPLETION|CONDITION_NUMBER|CONNECT|CONNECTION|'
r'CONNECTION_NAME|CONSTRAINT|CONSTRAINTS|CONSTRAINT_CATALOG|'
r'CONSTRAINT_NAME|CONSTRAINT_SCHEMA|CONSTRUCTOR|CONTAINS|'
r'CONTINUE|CONVERSION|CONVERT|COPY|CORRESPONTING|COUNT|'
r'CREATE|CREATEDB|CREATEUSER|CROSS|CUBE|CURRENT|CURRENT_DATE|'
r'CURRENT_PATH|CURRENT_ROLE|CURRENT_TIME|CURRENT_TIMESTAMP|'
r'CURRENT_USER|CURSOR|CURSOR_NAME|CYCLE|DATA|DATABASE|'
r'DATETIME_INTERVAL_CODE|DATETIME_INTERVAL_PRECISION|DAY|'
r'DEALLOCATE|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|'
r'DEFINED|DEFINER|DELETE|DELIMITER|DELIMITERS|DEREF|DESC|'
r'DESCRIBE|DESCRIPTOR|DESTROY|DESTRUCTOR|DETERMINISTIC|'
r'DIAGNOSTICS|DICTIONARY|DISCONNECT|DISPATCH|DISTINCT|DO|'
r'DOMAIN|DROP|DYNAMIC|DYNAMIC_FUNCTION|DYNAMIC_FUNCTION_CODE|'
r'EACH|ELSE|ENCODING|ENCRYPTED|END|END-EXEC|EQUALS|ESCAPE|EVERY|'
r'EXCEPT|ESCEPTION|EXCLUDING|EXCLUSIVE|EXEC|EXECUTE|EXISTING|'
r'EXISTS|EXPLAIN|EXTERNAL|EXTRACT|FALSE|FETCH|FINAL|FIRST|FOR|'
r'FORCE|FOREIGN|FORTRAN|FORWARD|FOUND|FREE|FREEZE|FROM|FULL|'
r'FUNCTION|G|GENERAL|GENERATED|GET|GLOBAL|GO|GOTO|GRANT|GRANTED|'
r'GROUP|GROUPING|HANDLER|HAVING|HIERARCHY|HOLD|HOST|IDENTITY|'
r'IGNORE|ILIKE|IMMEDIATE|IMMUTABLE|IMPLEMENTATION|IMPLICIT|IN|'
r'INCLUDING|INCREMENT|INDEX|INDITCATOR|INFIX|INHERITS|INITIALIZE|'
r'INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTANTIABLE|'
r'INSTEAD|INTERSECT|INTO|INVOKER|IS|ISNULL|ISOLATION|ITERATE|JOIN|'
r'KEY|KEY_MEMBER|KEY_TYPE|LANCOMPILER|LANGUAGE|LARGE|LAST|'
r'LATERAL|LEADING|LEFT|LENGTH|LESS|LEVEL|LIKE|LIMIT|LISTEN|LOAD|'
r'LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATION|LOCATOR|LOCK|LOWER|'
r'MAP|MATCH|MAX|MAXVALUE|MESSAGE_LENGTH|MESSAGE_OCTET_LENGTH|'
r'MESSAGE_TEXT|METHOD|MIN|MINUTE|MINVALUE|MOD|MODE|MODIFIES|'
r'MODIFY|MONTH|MORE|MOVE|MUMPS|NAMES|NATIONAL|NATURAL|NCHAR|'
r'NCLOB|NEW|NEXT|NO|NOCREATEDB|NOCREATEUSER|NONE|NOT|NOTHING|'
r'NOTIFY|NOTNULL|NULL|NULLABLE|NULLIF|OBJECT|OCTET_LENGTH|OF|OFF|'
r'OFFSET|OIDS|OLD|ON|ONLY|OPEN|OPERATION|OPERATOR|OPTION|OPTIONS|'
r'OR|ORDER|ORDINALITY|OUT|OUTER|OUTPUT|OVERLAPS|OVERLAY|OVERRIDING|'
r'OWNER|PAD|PARAMETER|PARAMETERS|PARAMETER_MODE|PARAMATER_NAME|'
r'PARAMATER_ORDINAL_POSITION|PARAMETER_SPECIFIC_CATALOG|'
r'PARAMETER_SPECIFIC_NAME|PARAMATER_SPECIFIC_SCHEMA|PARTIAL|'
r'PASCAL|PENDANT|PLACING|PLI|POSITION|POSTFIX|PRECISION|PREFIX|'
r'PREORDER|PREPARE|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURAL|'
r'PROCEDURE|PUBLIC|READ|READS|RECHECK|RECURSIVE|REF|REFERENCES|'
r'REFERENCING|REINDEX|RELATIVE|RENAME|REPEATABLE|REPLACE|RESET|'
r'RESTART|RESTRICT|RESULT|RETURN|RETURNED_LENGTH|'
r'RETURNED_OCTET_LENGTH|RETURNED_SQLSTATE|RETURNS|REVOKE|RIGHT|'
r'ROLE|ROLLBACK|ROLLUP|ROUTINE|ROUTINE_CATALOG|ROUTINE_NAME|'
r'ROUTINE_SCHEMA|ROW|ROWS|ROW_COUNT|RULE|SAVE_POINT|SCALE|SCHEMA|'
r'SCHEMA_NAME|SCOPE|SCROLL|SEARCH|SECOND|SECURITY|SELECT|SELF|'
r'SENSITIVE|SERIALIZABLE|SERVER_NAME|SESSION|SESSION_USER|SET|'
r'SETOF|SETS|SHARE|SHOW|SIMILAR|SIMPLE|SIZE|SOME|SOURCE|SPACE|'
r'SPECIFIC|SPECIFICTYPE|SPECIFIC_NAME|SQL|SQLCODE|SQLERROR|'
r'SQLEXCEPTION|SQLSTATE|SQLWARNINIG|STABLE|START|STATE|STATEMENT|'
r'STATIC|STATISTICS|STDIN|STDOUT|STORAGE|STRICT|STRUCTURE|STYPE|'
r'SUBCLASS_ORIGIN|SUBLIST|SUBSTRING|SUM|SYMMETRIC|SYSID|SYSTEM|'
r'SYSTEM_USER|TABLE|TABLE_NAME| TEMP|TEMPLATE|TEMPORARY|TERMINATE|'
r'THAN|THEN|TIMESTAMP|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TOAST|'
r'TRAILING|TRANSATION|TRANSACTIONS_COMMITTED|'
r'TRANSACTIONS_ROLLED_BACK|TRANSATION_ACTIVE|TRANSFORM|'
r'TRANSFORMS|TRANSLATE|TRANSLATION|TREAT|TRIGGER|TRIGGER_CATALOG|'
r'TRIGGER_NAME|TRIGGER_SCHEMA|TRIM|TRUE|TRUNCATE|TRUSTED|TYPE|'
r'UNCOMMITTED|UNDER|UNENCRYPTED|UNION|UNIQUE|UNKNOWN|UNLISTEN|'
r'UNNAMED|UNNEST|UNTIL|UPDATE|UPPER|USAGE|USER|'
r'USER_DEFINED_TYPE_CATALOG|USER_DEFINED_TYPE_NAME|'
r'USER_DEFINED_TYPE_SCHEMA|USING|VACUUM|VALID|VALIDATOR|VALUES|'
r'VARIABLE|VERBOSE|VERSION|VIEW|VOLATILE|WHEN|WHENEVER|WHERE|'
r'WITH|WITHOUT|WORK|WRITE|YEAR|ZONE)\b', Keyword),
(r'(ARRAY|BIGINT|BINARY|BIT|BLOB|BOOLEAN|CHAR|CHARACTER|DATE|'
r'DEC|DECIMAL|FLOAT|INT|INTEGER|INTERVAL|NUMBER|NUMERIC|REAL|'
r'SERIAL|SMALLINT|VARCHAR|VARYING|INT8|SERIAL8|TEXT)\b',
Name.Builtin),
(r'[+*/<>=~!@#%^&|`?^-]', Operator),
(r'[0-9]+', Number.Integer),
# TODO: Backslash escapes?
(r"'(''|[^'])*'", String.Single),
(r'"(""|[^"])*"', String.Symbol), # not a real string literal in ANSI SQL
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
(r'[;:()\[\],\.]', Punctuation)
],
'multiline-comments': [
(r'/\*', Comment.Multiline, 'multiline-comments'),
(r'\*/', Comment.Multiline, '#pop'),
(r'[^/\*]+', Comment.Multiline),
(r'[/*]', Comment.Multiline)
]
}
class MySqlLexer(RegexLexer):
"""
Special lexer for MySQL.
"""
name = 'MySQL'
aliases = ['mysql']
mimetypes = ['text/x-mysql']
flags = re.IGNORECASE
tokens = {
'root': [
(r'\s+', Text),
(r'(#|--\s+).*?\n', Comment.Single),
(r'/\*', Comment.Multiline, 'multiline-comments'),
(r'[0-9]+', Number.Integer),
(r'[0-9]*\.[0-9]+(e[+-][0-9]+)', Number.Float),
# TODO: add backslash escapes
(r"'(''|[^'])*'", String.Single),
(r'"(""|[^"])*"', String.Double),
(r"`(``|[^`])*`", String.Symbol),
(r'[+*/<>=~!@#%^&|`?^-]', Operator),
(r'\b(tinyint|smallint|mediumint|int|integer|bigint|date|'
r'datetime|time|bit|bool|tinytext|mediumtext|longtext|text|'
r'tinyblob|mediumblob|longblob|blob|float|double|double\s+'
r'precision|real|numeric|dec|decimal|timestamp|year|char|'
r'varchar|varbinary|varcharacter|enum|set)(\b\s*)(\()?',
bygroups(Keyword.Type, Text, Punctuation)),
(r'\b(add|all|alter|analyze|and|as|asc|asensitive|before|between|'
r'bigint|binary|blob|both|by|call|cascade|case|change|char|'
r'character|check|collate|column|condition|constraint|continue|'
r'convert|create|cross|current_date|current_time|'
r'current_timestamp|current_user|cursor|database|databases|'
r'day_hour|day_microsecond|day_minute|day_second|dec|decimal|'
r'declare|default|delayed|delete|desc|describe|deterministic|'
r'distinct|distinctrow|div|double|drop|dual|each|else|elseif|'
r'enclosed|escaped|exists|exit|explain|fetch|float|float4|float8'
r'|for|force|foreign|from|fulltext|grant|group|having|'
r'high_priority|hour_microsecond|hour_minute|hour_second|if|'
r'ignore|in|index|infile|inner|inout|insensitive|insert|int|'
r'int1|int2|int3|int4|int8|integer|interval|into|is|iterate|'
r'join|key|keys|kill|leading|leave|left|like|limit|lines|load|'
r'localtime|localtimestamp|lock|long|loop|low_priority|match|'
r'minute_microsecond|minute_second|mod|modifies|natural|'
r'no_write_to_binlog|not|numeric|on|optimize|option|optionally|'
r'or|order|out|outer|outfile|precision|primary|procedure|purge|'
r'raid0|read|reads|real|references|regexp|release|rename|repeat|'
r'replace|require|restrict|return|revoke|right|rlike|schema|'
r'schemas|second_microsecond|select|sensitive|separator|set|'
r'show|smallint|soname|spatial|specific|sql|sql_big_result|'
r'sql_calc_found_rows|sql_small_result|sqlexception|sqlstate|'
r'sqlwarning|ssl|starting|straight_join|table|terminated|then|'
r'to|trailing|trigger|undo|union|unique|unlock|unsigned|update|'
r'usage|use|using|utc_date|utc_time|utc_timestamp|values|'
r'varying|when|where|while|with|write|x509|xor|year_month|'
r'zerofill)\b', Keyword),
# TODO: this list is not complete
(r'\b(auto_increment|engine|charset|tables)\b', Keyword.Pseudo),
(r'(true|false|null)', Name.Constant),
(r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()',
bygroups(Name.Function, Text, Punctuation)),
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
(r'@[A-Za-z0-9]*[._]*[A-Za-z0-9]*', Name.Variable),
(r'[;:()\[\],\.]', Punctuation)
],
'multiline-comments': [
(r'/\*', Comment.Multiline, 'multiline-comments'),
(r'\*/', Comment.Multiline, '#pop'),
(r'[^/\*]+', Comment.Multiline),
(r'[/*]', Comment.Multiline)
]
}
class SqliteConsoleLexer(Lexer):
"""
Lexer for example sessions using sqlite3.
*New in Pygments 0.11.*
"""
name = 'sqlite3con'
aliases = ['sqlite3']
filenames = ['*.sqlite3-console']
mimetypes = ['text/x-sqlite3-console']
def get_tokens_unprocessed(self, data):
sql = SqlLexer(**self.options)
curcode = ''
insertions = []
for match in line_re.finditer(data):
line = match.group()
if line.startswith('sqlite> ') or line.startswith(' ...> '):
insertions.append((len(curcode),
[(0, Generic.Prompt, line[:8])]))
curcode += line[8:]
else:
if curcode:
for item in do_insertions(insertions,
sql.get_tokens_unprocessed(curcode)):
yield item
curcode = ''
insertions = []
if line.startswith('SQL error: '):
yield (match.start(), Generic.Traceback, line)
else:
yield (match.start(), Generic.Output, line)
if curcode:
for item in do_insertions(insertions,
sql.get_tokens_unprocessed(curcode)):
yield item
class BrainfuckLexer(RegexLexer):
"""
Lexer for the esoteric `BrainFuck <http://www.muppetlabs.com/~breadbox/bf/>`_
language.
"""
name = 'Brainfuck'
aliases = ['brainfuck', 'bf']
filenames = ['*.bf', '*.b']
mimetypes = ['application/x-brainfuck']
tokens = {
'common': [
# use different colors for different instruction types
(r'[.,]+', Name.Tag),
(r'[+-]+', Name.Builtin),
(r'[<>]+', Name.Variable),
(r'[^.,+\-<>\[\]]+', Comment),
],
'root': [
(r'\[', Keyword, 'loop'),
(r'\]', Error),
include('common'),
],
'loop': [
(r'\[', Keyword, '#push'),
(r'\]', Keyword, '#pop'),
include('common'),
]
}
class BefungeLexer(RegexLexer):
"""
Lexer for the esoteric `Befunge <http://en.wikipedia.org/wiki/Befunge>`_
language.
*New in Pygments 0.7.*
"""
name = 'Befunge'
aliases = ['befunge']
filenames = ['*.befunge']
mimetypes = ['application/x-befunge']
tokens = {
'root': [
(r'[0-9a-f]', Number),
(r'[\+\*/%!`-]', Operator), # Traditional math
(r'[<>^v?\[\]rxjk]', Name.Variable), # Move, imperatives
(r'[:\\$.,n]', Name.Builtin), # Stack ops, imperatives
(r'[|_mw]', Keyword),
(r'[{}]', Name.Tag), # Befunge-98 stack ops
(r'".*?"', String.Double), # Strings don't appear to allow escapes
(r'\'.', String.Single), # Single character
(r'[#;]', Comment), # Trampoline... depends on direction hit
(r'[pg&~=@iotsy]', Keyword), # Misc
(r'[()A-Z]', Comment), # Fingerprints
(r'\s+', Text), # Whitespace doesn't matter
],
}
class BashLexer(RegexLexer):
"""
Lexer for (ba)sh shell scripts.
*New in Pygments 0.6.*
"""
name = 'Bash'
aliases = ['bash', 'sh']
filenames = ['*.sh', '*.ebuild', '*.eclass']
mimetypes = ['application/x-sh', 'application/x-shellscript']
tokens = {
'root': [
include('basic'),
(r'\$\(\(', Keyword, 'math'),
(r'\$\(', Keyword, 'paren'),
(r'\${#?', Keyword, 'curly'),
(r'`', String.Backtick, 'backticks'),
include('data'),
],
'basic': [
(r'\b(if|fi|else|while|do|done|for|then|return|function|case|'
r'select|continue|until|esac|elif)\s*\b',
Keyword),
(r'\b(alias|bg|bind|break|builtin|caller|cd|command|compgen|'
r'complete|declare|dirs|disown|echo|enable|eval|exec|exit|'
r'export|false|fc|fg|getopts|hash|help|history|jobs|kill|let|'
r'local|logout|popd|printf|pushd|pwd|read|readonly|set|shift|'
r'shopt|source|suspend|test|time|times|trap|true|type|typeset|'
r'ulimit|umask|unalias|unset|wait)\s*\b(?!\.)',
Name.Builtin),
(r'#.*\n', Comment),
(r'\\[\w\W]', String.Escape),
(r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)),
(r'[\[\]{}()=]', Operator),
(r'<<\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
(r'&&|\|\|', Operator),
],
'data': [
(r'(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
(r"(?s)\$?'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
(r';', Text),
(r'\s+', Text),
(r'[^=\s\n\[\]{}()$"\'`\\<]+', Text),
(r'\d+(?= |\Z)', Number),
(r'\$#?(\w+|.)', Name.Variable),
(r'<', Text),
],
'curly': [
(r'}', Keyword, '#pop'),
(r':-', Keyword),
(r'[a-zA-Z0-9_]+', Name.Variable),
(r'[^}:"\'`$]+', Punctuation),
(r':', Punctuation),
include('root'),
],
'paren': [
(r'\)', Keyword, '#pop'),
include('root'),
],
'math': [
(r'\)\)', Keyword, '#pop'),
(r'[-+*/%^|&]|\*\*|\|\|', Operator),
(r'\d+', Number),
include('root'),
],
'backticks': [
(r'`', String.Backtick, '#pop'),
include('root'),
],
}
def analyse_text(text):
return shebang_matches(text, r'(ba|z|)sh')
class BashSessionLexer(Lexer):
"""
Lexer for simplistic shell sessions.
*New in Pygments 1.1.*
"""
name = 'Bash Session'
aliases = ['console']
filenames = ['*.sh-session']
mimetypes = ['application/x-shell-session']
def get_tokens_unprocessed(self, text):
bashlexer = BashLexer(**self.options)
pos = 0
curcode = ''
insertions = []
for match in line_re.finditer(text):
line = match.group()
m = re.match(r'^((?:|sh\S*?|\w+\S+[@:]\S+(?:\s+\S+)?|\[\S+[@:]'
r'[^\n]+\].+)[$#%])(.*\n?)', line)
if m:
# To support output lexers (say diff output), the output
# needs to be broken by prompts whenever the output lexer
# changes.
if not insertions:
pos = match.start()
insertions.append((len(curcode),
[(0, Generic.Prompt, m.group(1))]))
curcode += m.group(2)
elif line.startswith('>'):
insertions.append((len(curcode),
[(0, Generic.Prompt, line[:1])]))
curcode += line[1:]
else:
if insertions:
toks = bashlexer.get_tokens_unprocessed(curcode)
for i, t, v in do_insertions(insertions, toks):
yield pos+i, t, v
yield match.start(), Generic.Output, line
insertions = []
curcode = ''
if insertions:
for i, t, v in do_insertions(insertions,
bashlexer.get_tokens_unprocessed(curcode)):
yield pos+i, t, v
class BatchLexer(RegexLexer):
"""
Lexer for the DOS/Windows Batch file format.
*New in Pygments 0.7.*
"""
name = 'Batchfile'
aliases = ['bat']
filenames = ['*.bat', '*.cmd']
mimetypes = ['application/x-dos-batch']
flags = re.MULTILINE | re.IGNORECASE
tokens = {
'root': [
# Lines can start with @ to prevent echo
(r'^\s*@', Punctuation),
(r'^(\s*)(rem\s.*)$', bygroups(Text, Comment)),
(r'".*?"', String.Double),
(r"'.*?'", String.Single),
# If made more specific, make sure you still allow expansions
# like %~$VAR:zlt
(r'%%?[~$:\w]+%?', Name.Variable),
(r'::.*', Comment), # Technically :: only works at BOL
(r'(set)(\s+)(\w+)', bygroups(Keyword, Text, Name.Variable)),
(r'(call)(\s+)(:\w+)', bygroups(Keyword, Text, Name.Label)),
(r'(goto)(\s+)(\w+)', bygroups(Keyword, Text, Name.Label)),
(r'\b(set|call|echo|on|off|endlocal|for|do|goto|if|pause|'
r'setlocal|shift|errorlevel|exist|defined|cmdextversion|'
r'errorlevel|else|cd|md|del|deltree|cls|choice)\b', Keyword),
(r'\b(equ|neq|lss|leq|gtr|geq)\b', Operator),
include('basic'),
(r'.', Text),
],
'echo': [
# Escapes only valid within echo args?
(r'\^\^|\^<|\^>|\^\|', String.Escape),
(r'\n', Text, '#pop'),
include('basic'),
(r'[^\'"^]+', Text),
],
'basic': [
(r'".*?"', String.Double),
(r"'.*?'", String.Single),
(r'`.*?`', String.Backtick),
(r'-?\d+', Number),
(r',', Punctuation),
(r'=', Operator),
(r'/\S+', Name),
(r':\w+', Name.Label),
(r'\w:\w+', Text),
(r'([<>|])(\s*)(\w+)', bygroups(Punctuation, Text, Name)),
],
}
class RedcodeLexer(RegexLexer):
"""
A simple Redcode lexer based on ICWS'94.
Contributed by Adam Blinkinsop <[email protected]>.
*New in Pygments 0.8.*
"""
name = 'Redcode'
aliases = ['redcode']
filenames = ['*.cw']
opcodes = ['DAT','MOV','ADD','SUB','MUL','DIV','MOD',
'JMP','JMZ','JMN','DJN','CMP','SLT','SPL',
'ORG','EQU','END']
modifiers = ['A','B','AB','BA','F','X','I']
tokens = {
'root': [
# Whitespace:
(r'\s+', Text),
(r';.*$', Comment.Single),
# Lexemes:
# Identifiers
(r'\b(%s)\b' % '|'.join(opcodes), Name.Function),
(r'\b(%s)\b' % '|'.join(modifiers), Name.Decorator),
(r'[A-Za-z_][A-Za-z_0-9]+', Name),
# Operators
(r'[-+*/%]', Operator),
(r'[#$@<>]', Operator), # mode
(r'[.,]', Punctuation), # mode
# Numbers
(r'[-+]?\d+', Number.Integer),
],
}
class MOOCodeLexer(RegexLexer):
"""
For `MOOCode <http://www.moo.mud.org/>`_ (the MOO scripting
language).
*New in Pygments 0.9.*
"""
name = 'MOOCode'
filenames = ['*.moo']
aliases = ['moocode']
mimetypes = ['text/x-moocode']
tokens = {
'root' : [
# Numbers
(r'(0|[1-9][0-9_]*)', Number.Integer),
# Strings
(r'"(\\\\|\\"|[^"])*"', String),
# exceptions
(r'(E_PERM|E_DIV)', Name.Exception),
# db-refs
(r'((#[-0-9]+)|(\$[a-z_A-Z0-9]+))', Name.Entity),
# Keywords
(r'\b(if|else|elseif|endif|for|endfor|fork|endfork|while'
r'|endwhile|break|continue|return|try'
r'|except|endtry|finally|in)\b', Keyword),
# builtins
(r'(random|length)', Name.Builtin),
# special variables
(r'(player|caller|this|args)', Name.Variable.Instance),
# skip whitespace
(r'\s+', Text),
(r'\n', Text),
# other operators
(r'([!;=,{}&\|:\.\[\]@\(\)\<\>\?]+)', Operator),
# function call
(r'([a-z_A-Z0-9]+)(\()', bygroups(Name.Function, Operator)),
# variables
(r'([a-zA-Z_0-9]+)', Text),
]
}
class SmalltalkLexer(RegexLexer):
"""
For `Smalltalk <http://www.smalltalk.org/>`_ syntax.
Contributed by Stefan Matthias Aust.
Rewritten by Nils Winter.
*New in Pygments 0.10.*
"""
name = 'Smalltalk'
filenames = ['*.st']
aliases = ['smalltalk', 'squeak']
mimetypes = ['text/x-smalltalk']
tokens = {
'root' : [
(r'(<)(\w+:)(.*?)(>)', bygroups(Text, Keyword, Text, Text)),
include('squeak fileout'),
include('whitespaces'),
include('method definition'),
(r'(\|)([\w\s]*)(\|)', bygroups(Operator, Name.Variable, Operator)),
include('objects'),
(r'\^|\:=|\_', Operator),
# temporaries
(r'[\]({}.;!]', Text),
],
'method definition' : [
# Not perfect can't allow whitespaces at the beginning and the
# without breaking everything
(r'([a-zA-Z]+\w*:)(\s*)(\w+)',
bygroups(Name.Function, Text, Name.Variable)),
(r'^(\b[a-zA-Z]+\w*\b)(\s*)$', bygroups(Name.Function, Text)),
(r'^([-+*/\\~<>=|&!?,@%]+)(\s*)(\w+)(\s*)$',
bygroups(Name.Function, Text, Name.Variable, Text)),
],
'blockvariables' : [
include('whitespaces'),
(r'(:)(\s*)([A-Za-z\w]+)',
bygroups(Operator, Text, Name.Variable)),
(r'\|', Operator, '#pop'),
(r'', Text, '#pop'), # else pop
],
'literals' : [
(r'\'[^\']*\'', String, 'afterobject'),
(r'\$.', String.Char, 'afterobject'),
(r'#\(', String.Symbol, 'parenth'),
(r'\)', Text, 'afterobject'),
(r'(\d+r)?-?\d+(\.\d+)?(e-?\d+)?', Number, 'afterobject'),
],
'_parenth_helper' : [
include('whitespaces'),
(r'[-+*/\\~<>=|&#!?,@%\w+:]+', String.Symbol),
# literals
(r'\'[^\']*\'', String),
(r'\$.', String.Char),
(r'(\d+r)?-?\d+(\.\d+)?(e-?\d+)?', Number),
(r'#*\(', String.Symbol, 'inner_parenth'),
],
'parenth' : [
# This state is a bit tricky since
# we can't just pop this state
(r'\)', String.Symbol, ('root','afterobject')),
include('_parenth_helper'),
],
'inner_parenth': [
(r'\)', String.Symbol, '#pop'),
include('_parenth_helper'),
],
'whitespaces' : [
# skip whitespace and comments
(r'\s+', Text),
(r'"[^"]*"', Comment),
],
'objects' : [
(r'\[', Text, 'blockvariables'),
(r'\]', Text, 'afterobject'),
(r'\b(self|super|true|false|nil|thisContext)\b',
Name.Builtin.Pseudo, 'afterobject'),
(r'\b[A-Z]\w*(?!:)\b', Name.Class, 'afterobject'),
(r'\b[a-z]\w*(?!:)\b', Name.Variable, 'afterobject'),
(r'#("[^"]*"|[-+*/\\~<>=|&!?,@%]+|[\w:]+)',
String.Symbol, 'afterobject'),
include('literals'),
],
'afterobject' : [
(r'! !$', Keyword , '#pop'), # squeak chunk delimeter
include('whitespaces'),
(r'\b(ifTrue:|ifFalse:|whileTrue:|whileFalse:|timesRepeat:)',
Name.Builtin, '#pop'),
(r'\b(new\b(?!:))', Name.Builtin),
(r'\:=|\_', Operator, '#pop'),
(r'\b[a-zA-Z]+\w*:', Name.Function, '#pop'),
(r'\b[a-zA-Z]+\w*', Name.Function),
(r'\w+:?|[-+*/\\~<>=|&!?,@%]+', Name.Function, '#pop'),
(r'\.', Punctuation, '#pop'),
(r';', Punctuation),
(r'[\])}]', Text),
(r'[\[({]', Text, '#pop'),
],
'squeak fileout' : [
# Squeak fileout format (optional)
(r'^"[^"]*"!', Keyword),
(r"^'[^']*'!", Keyword),
(r'^(!)(\w+)( commentStamp: )(.*?)( prior: .*?!\n)(.*?)(!)',
bygroups(Keyword, Name.Class, Keyword, String, Keyword, Text, Keyword)),
(r'^(!)(\w+(?: class)?)( methodsFor: )(\'[^\']*\')(.*?!)',
bygroups(Keyword, Name.Class, Keyword, String, Keyword)),
(r'^(\w+)( subclass: )(#\w+)'
r'(\s+instanceVariableNames: )(.*?)'
r'(\s+classVariableNames: )(.*?)'
r'(\s+poolDictionaries: )(.*?)'
r'(\s+category: )(.*?)(!)',
bygroups(Name.Class, Keyword, String.Symbol, Keyword, String, Keyword,
String, Keyword, String, Keyword, String, Keyword)),
(r'^(\w+(?: class)?)(\s+instanceVariableNames: )(.*?)(!)',
bygroups(Name.Class, Keyword, String, Keyword)),
(r'(!\n)(\].*)(! !)$', bygroups(Keyword, Text, Keyword)),
(r'! !$', Keyword),
],
}
class TcshLexer(RegexLexer):
"""
Lexer for tcsh scripts.
*New in Pygments 0.10.*
"""
name = 'Tcsh'
aliases = ['tcsh', 'csh']
filenames = ['*.tcsh', '*.csh']
mimetypes = ['application/x-csh']
tokens = {
'root': [
include('basic'),
(r'\$\(', Keyword, 'paren'),
(r'\${#?', Keyword, 'curly'),
(r'`', String.Backtick, 'backticks'),
include('data'),
],
'basic': [
(r'\b(if|endif|else|while|then|foreach|case|default|'
r'continue|goto|breaksw|end|switch|endsw)\s*\b',
Keyword),
(r'\b(alias|alloc|bg|bindkey|break|builtins|bye|caller|cd|chdir|'
r'complete|dirs|echo|echotc|eval|exec|exit|'
r'fg|filetest|getxvers|glob|getspath|hashstat|history|hup|inlib|jobs|kill|'
r'limit|log|login|logout|ls-F|migrate|newgrp|nice|nohup|notify|'
r'onintr|popd|printenv|pushd|rehash|repeat|rootnode|popd|pushd|set|shift|'
r'sched|setenv|setpath|settc|setty|setxvers|shift|source|stop|suspend|'
r'source|suspend|telltc|time|'
r'umask|unalias|uncomplete|unhash|universe|unlimit|unset|unsetenv|'
r'ver|wait|warp|watchlog|where|which)\s*\b',
Name.Builtin),
(r'#.*\n', Comment),
(r'\\[\w\W]', String.Escape),
(r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)),
(r'[\[\]{}()=]+', Operator),
(r'<<\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
],
'data': [
(r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
(r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
(r'\s+', Text),
(r'[^=\s\n\[\]{}()$"\'`\\]+', Text),
(r'\d+(?= |\Z)', Number),
(r'\$#?(\w+|.)', Name.Variable),
],
'curly': [
(r'}', Keyword, '#pop'),
(r':-', Keyword),
(r'[a-zA-Z0-9_]+', Name.Variable),
(r'[^}:"\'`$]+', Punctuation),
(r':', Punctuation),
include('root'),
],
'paren': [
(r'\)', Keyword, '#pop'),
include('root'),
],
'backticks': [
(r'`', String.Backtick, '#pop'),
include('root'),
],
}
class LogtalkLexer(RegexLexer):
"""
For `Logtalk <http://logtalk.org/>`_ source code.
*New in Pygments 0.10.*
"""
name = 'Logtalk'
aliases = ['logtalk']
filenames = ['*.lgt']
mimetypes = ['text/x-logtalk']
tokens = {
'root': [
# Directives
(r'^\s*:-\s',Punctuation,'directive'),
# Comments
(r'%.*?\n', Comment),
(r'/\*(.|\n)*?\*/',Comment),
# Whitespace
(r'\n', Text),
(r'\s+', Text),
# Numbers
(r"0'.", Number),
(r'0b[01]+', Number),
(r'0o[0-7]+', Number),
(r'0x[0-9a-fA-F]+', Number),
(r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number),
# Variables
(r'([A-Z_][a-zA-Z0-9_]*)', Name.Variable),
# Event handlers
(r'(after|before)(?=[(])', Keyword),
# Execution-context methods
(r'(parameter|this|se(lf|nder))(?=[(])', Keyword),
# Reflection
(r'(current_predicate|predicate_property)(?=[(])', Keyword),
# DCGs and term expansion
(r'(expand_(goal|term)|(goal|term)_expansion|phrase)(?=[(])',
Keyword),
# Entity
(r'(abolish|c(reate|urrent))_(object|protocol|category)(?=[(])',
Keyword),
(r'(object|protocol|category)_property(?=[(])', Keyword),
# Entity relations
(r'complements_object(?=[(])', Keyword),
(r'extends_(object|protocol|category)(?=[(])', Keyword),
(r'imp(lements_protocol|orts_category)(?=[(])', Keyword),
(r'(instantiat|specializ)es_class(?=[(])', Keyword),
# Events
(r'(current_event|(abolish|define)_events)(?=[(])', Keyword),
# Flags
(r'(current|set)_logtalk_flag(?=[(])', Keyword),
# Compiling, loading, and library paths
(r'logtalk_(compile|l(ibrary_path|oad))(?=[(])', Keyword),
# Database
(r'(clause|retract(all)?)(?=[(])', Keyword),
(r'a(bolish|ssert(a|z))(?=[(])', Keyword),
# Control
(r'(ca(ll|tch)|throw)(?=[(])', Keyword),
(r'(fail|true)\b', Keyword),
# All solutions
(r'((bag|set)of|f(ind|or)all)(?=[(])', Keyword),
# Multi-threading meta-predicates
(r'threaded(_(call|once|ignore|exit|peek|wait|notify))?(?=[(])',
Keyword),
# Term unification
(r'unify_with_occurs_check(?=[(])', Keyword),
# Term creation and decomposition
(r'(functor|arg|copy_term)(?=[(])', Keyword),
# Evaluable functors
(r'(rem|mod|abs|sign)(?=[(])', Keyword),
(r'float(_(integer|fractional)_part)?(?=[(])', Keyword),
(r'(floor|truncate|round|ceiling)(?=[(])', Keyword),
# Other arithmetic functors
(r'(cos|atan|exp|log|s(in|qrt))(?=[(])', Keyword),
# Term testing
(r'(var|atom(ic)?|integer|float|compound|n(onvar|umber))(?=[(])',
Keyword),
# Stream selection and control
(r'(curren|se)t_(in|out)put(?=[(])', Keyword),
(r'(open|close)(?=[(])', Keyword),
(r'flush_output(?=[(])', Keyword),
(r'(at_end_of_stream|flush_output)\b', Keyword),
(r'(stream_property|at_end_of_stream|set_stream_position)(?=[(])',
Keyword),
# Character and byte input/output
(r'(nl|(get|peek|put)_(byte|c(har|ode)))(?=[(])', Keyword),
(r'\bnl\b', Keyword),
# Term input/output
(r'read(_term)?(?=[(])', Keyword),
(r'write(q|_(canonical|term))?(?=[(])', Keyword),
(r'(current_)?op(?=[(])', Keyword),
(r'(current_)?char_conversion(?=[(])', Keyword),
# Atomic term processing
(r'atom_(length|c(hars|o(ncat|des)))(?=[(])', Keyword),
(r'(char_code|sub_atom)(?=[(])', Keyword),
(r'number_c(har|ode)s(?=[(])', Keyword),
# Implementation defined hooks functions
(r'(se|curren)t_prolog_flag(?=[(])', Keyword),
(r'\bhalt\b', Keyword),
(r'halt(?=[(])', Keyword),
# Message sending operators
(r'(::|:|\^\^)', Operator),
# External call
(r'[{}]', Keyword),
# Logic and control
(r'\bonce(?=[(])', Keyword),
(r'\brepeat\b', Keyword),
# Bitwise functors
(r'(>>|<<|/\\|\\\\|\\)', Operator),
# Arithemtic evaluation
(r'\bis\b', Keyword),
# Arithemtic comparison
(r'(=:=|=\\=|<|=<|>=|>)', Operator),
# Term creation and decomposition
(r'=\.\.', Operator),
# Term unification
(r'(=|\\=)', Operator),
# Term comparison
(r'(==|\\==|@=<|@<|@>=|@>)', Operator),
# Evaluable functors
(r'(//|[-+*/])', Operator),
(r'\b(mod|rem)\b', Operator),
# Other arithemtic functors
(r'\b\*\*\b', Operator),
# DCG rules
(r'-->', Operator),
# Control constructs
(r'([!;]|->)', Operator),
# Logic and control
(r'\\+', Operator),
# Mode operators
(r'[?@]', Operator),
# Strings
(r'"(\\\\|\\"|[^"])*"', String),
# Ponctuation
(r'[()\[\],.|]', Text),
# Atoms
(r"[a-z][a-zA-Z0-9_]*", Text),
(r"[']", String, 'quoted_atom'),
],
'quoted_atom': [
(r"['][']", String),
(r"[']", String, '#pop'),
(r'\\([\\abfnrtv"\']|(x[a-fA-F0-9]+|[0-7]+)\\)', String.Escape),
(r"[^\\'\n]+", String),
(r'\\', String),
],
'directive': [
# Conditional compilation directives
(r'(el)?if(?=[(])', Keyword, 'root'),
(r'(e(lse|ndif))[.]', Keyword, 'root'),
# Entity directives
(r'(category|object|protocol)(?=[(])', Keyword, 'entityrelations'),
(r'(end_(category|object|protocol))[.]',Keyword, 'root'),
# Predicate scope directives
(r'(public|protected|private)(?=[(])', Keyword, 'root'),
# Other directives
(r'e(n(coding|sure_loaded)|xport)(?=[(])', Keyword, 'root'),
(r'in(fo|itialization)(?=[(])', Keyword, 'root'),
(r'(dynamic|synchronized|threaded)[.]', Keyword, 'root'),
(r'(alias|d(ynamic|iscontiguous)|m(eta_predicate|ode|ultifile)|'
r's(et_(logtalk|prolog)_flag|ynchronized))(?=[(])', Keyword, 'root'),
(r'op(?=[(])', Keyword, 'root'),
(r'(calls|reexport|use(s|_module))(?=[(])', Keyword, 'root'),
(r'[a-z][a-zA-Z0-9_]*(?=[(])', Text, 'root'),
(r'[a-z][a-zA-Z0-9_]*[.]', Text, 'root'),
],
'entityrelations': [
(r'(extends|i(nstantiates|mp(lements|orts))|specializes)(?=[(])',
Keyword),
# Numbers
(r"0'.", Number),
(r'0b[01]+', Number),
(r'0o[0-7]+', Number),
(r'0x[0-9a-fA-F]+', Number),
(r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number),
# Variables
(r'([A-Z_][a-zA-Z0-9_]*)', Name.Variable),
# Atoms
(r"[a-z][a-zA-Z0-9_]*", Text),
(r"[']", String, 'quoted_atom'),
# Strings
(r'"(\\\\|\\"|[^"])*"', String),
# End of entity-opening directive
(r'([)]\.)', Text, 'root'),
# Scope operator
(r'(::)', Operator),
# Ponctuation
(r'[()\[\],.|]', Text),
# Comments
(r'%.*?\n', Comment),
(r'/\*(.|\n)*?\*/',Comment),
# Whitespace
(r'\n', Text),
(r'\s+', Text),
]
}
def analyse_text(text):
if ':- object(' in text:
return True
if ':- protocol(' in text:
return True
if ':- category(' in text:
return True
return False
def _shortened(word):
dpos = word.find('$')
return '|'.join([word[:dpos] + word[dpos+1:i] + r'\b'
for i in range(len(word), dpos, -1)])
def _shortened_many(*words):
return '|'.join(map(_shortened, words))
class GnuplotLexer(RegexLexer):
"""
For `Gnuplot <http://gnuplot.info/>`_ plotting scripts.
*New in Pygments 0.11.*
"""
name = 'Gnuplot'
aliases = ['gnuplot']
filenames = ['*.plot', '*.plt']
mimetypes = ['text/x-gnuplot']
tokens = {
'root': [
include('whitespace'),
(_shortened('bi$nd'), Keyword, 'bind'),
(_shortened_many('ex$it', 'q$uit'), Keyword, 'quit'),
(_shortened('f$it'), Keyword, 'fit'),
(r'(if)(\s*)(\()', bygroups(Keyword, Text, Punctuation), 'if'),
(r'else\b', Keyword),
(_shortened('pa$use'), Keyword, 'pause'),
(_shortened_many('p$lot', 'rep$lot', 'sp$lot'), Keyword, 'plot'),
(_shortened('sa$ve'), Keyword, 'save'),
(_shortened('se$t'), Keyword, ('genericargs', 'optionarg')),
(_shortened_many('sh$ow', 'uns$et'),
Keyword, ('noargs', 'optionarg')),
(_shortened_many('low$er', 'ra$ise', 'ca$ll', 'cd$', 'cl$ear',
'h$elp', '\\?$', 'hi$story', 'l$oad', 'pr$int',
'pwd$', 're$read', 'res$et', 'scr$eendump',
'she$ll', 'sy$stem', 'up$date'),
Keyword, 'genericargs'),
(_shortened_many('pwd$', 're$read', 'res$et', 'scr$eendump',
'she$ll', 'test$'),
Keyword, 'noargs'),
('([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(=)',
bygroups(Name.Variable, Text, Operator), 'genericargs'),
('([a-zA-Z_][a-zA-Z0-9_]*)(\s*\(.*?\)\s*)(=)',
bygroups(Name.Function, Text, Operator), 'genericargs'),
(r'@[a-zA-Z_][a-zA-Z0-9_]*', Name.Constant), # macros
(r';', Keyword),
],
'comment': [
(r'[^\\\n]', Comment),
(r'\\\n', Comment),
(r'\\', Comment),
# don't add the newline to the Comment token
('', Comment, '#pop'),
],
'whitespace': [
('#', Comment, 'comment'),
(r'[ \t\v\f]+', Text),
],
'noargs': [
include('whitespace'),
# semicolon and newline end the argument list
(r';', Punctuation, '#pop'),
(r'\n', Text, '#pop'),
],
'dqstring': [
(r'"', String, '#pop'),
(r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
(r'[^\\"\n]+', String), # all other characters
(r'\\\n', String), # line continuation
(r'\\', String), # stray backslash
(r'\n', String, '#pop'), # newline ends the string too
],
'sqstring': [
(r"''", String), # escaped single quote
(r"'", String, '#pop'),
(r"[^\\'\n]+", String), # all other characters
(r'\\\n', String), # line continuation
(r'\\', String), # normal backslash
(r'\n', String, '#pop'), # newline ends the string too
],
'genericargs': [
include('noargs'),
(r'"', String, 'dqstring'),
(r"'", String, 'sqstring'),
(r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+', Number.Float),
(r'(\d+\.\d*|\.\d+)', Number.Float),
(r'-?\d+', Number.Integer),
('[,.~!%^&*+=|?:<>/-]', Operator),
('[{}()\[\]]', Punctuation),
(r'(eq|ne)\b', Operator.Word),
(r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()',
bygroups(Name.Function, Text, Punctuation)),
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
(r'@[a-zA-Z_][a-zA-Z0-9_]*', Name.Constant), # macros
(r'\\\n', Text),
],
'optionarg': [
include('whitespace'),
(_shortened_many(
"a$ll","an$gles","ar$row","au$toscale","b$ars","bor$der",
"box$width","cl$abel","c$lip","cn$trparam","co$ntour","da$ta",
"data$file","dg$rid3d","du$mmy","enc$oding","dec$imalsign",
"fit$","font$path","fo$rmat","fu$nction","fu$nctions","g$rid",
"hid$den3d","his$torysize","is$osamples","k$ey","keyt$itle",
"la$bel","li$nestyle","ls$","loa$dpath","loc$ale","log$scale",
"mac$ros","map$ping","map$ping3d","mar$gin","lmar$gin",
"rmar$gin","tmar$gin","bmar$gin","mo$use","multi$plot",
"mxt$ics","nomxt$ics","mx2t$ics","nomx2t$ics","myt$ics",
"nomyt$ics","my2t$ics","nomy2t$ics","mzt$ics","nomzt$ics",
"mcbt$ics","nomcbt$ics","of$fsets","or$igin","o$utput",
"pa$rametric","pm$3d","pal$ette","colorb$ox","p$lot",
"poi$ntsize","pol$ar","pr$int","obj$ect","sa$mples","si$ze",
"st$yle","su$rface","table$","t$erminal","termo$ptions","ti$cs",
"ticsc$ale","ticsl$evel","timef$mt","tim$estamp","tit$le",
"v$ariables","ve$rsion","vi$ew","xyp$lane","xda$ta","x2da$ta",
"yda$ta","y2da$ta","zda$ta","cbda$ta","xl$abel","x2l$abel",
"yl$abel","y2l$abel","zl$abel","cbl$abel","xti$cs","noxti$cs",
"x2ti$cs","nox2ti$cs","yti$cs","noyti$cs","y2ti$cs","noy2ti$cs",
"zti$cs","nozti$cs","cbti$cs","nocbti$cs","xdti$cs","noxdti$cs",
"x2dti$cs","nox2dti$cs","ydti$cs","noydti$cs","y2dti$cs",
"noy2dti$cs","zdti$cs","nozdti$cs","cbdti$cs","nocbdti$cs",
"xmti$cs","noxmti$cs","x2mti$cs","nox2mti$cs","ymti$cs",
"noymti$cs","y2mti$cs","noy2mti$cs","zmti$cs","nozmti$cs",
"cbmti$cs","nocbmti$cs","xr$ange","x2r$ange","yr$ange",
"y2r$ange","zr$ange","cbr$ange","rr$ange","tr$ange","ur$ange",
"vr$ange","xzeroa$xis","x2zeroa$xis","yzeroa$xis","y2zeroa$xis",
"zzeroa$xis","zeroa$xis","z$ero"), Name.Builtin, '#pop'),
],
'bind': [
('!', Keyword, '#pop'),
(_shortened('all$windows'), Name.Builtin),
include('genericargs'),
],
'quit': [
(r'gnuplot\b', Keyword),
include('noargs'),
],
'fit': [
(r'via\b', Name.Builtin),
include('plot'),
],
'if': [
(r'\)', Punctuation, '#pop'),
include('genericargs'),
],
'pause': [
(r'(mouse|any|button1|button2|button3)\b', Name.Builtin),
(_shortened('key$press'), Name.Builtin),
include('genericargs'),
],
'plot': [
(_shortened_many('ax$es', 'axi$s', 'bin$ary', 'ev$ery', 'i$ndex',
'mat$rix', 's$mooth', 'thru$', 't$itle',
'not$itle', 'u$sing', 'w$ith'),
Name.Builtin),
include('genericargs'),
],
'save': [
(_shortened_many('f$unctions', 's$et', 't$erminal', 'v$ariables'),
Name.Builtin),
include('genericargs'),
],
}
class PovrayLexer(RegexLexer):
"""
For `Persistence of Vision Raytracer <http://www.povray.org/>`_ files.
*New in Pygments 0.11.*
"""
name = 'POVRay'
aliases = ['pov']
filenames = ['*.pov', '*.inc']
mimetypes = ['text/x-povray']
tokens = {
'root': [
(r'/\*[\w\W]*?\*/', Comment.Multiline),
(r'//.*\n', Comment.Single),
(r'(?s)"(?:\\.|[^"\\])+"', String.Double),
(r'#(debug|default|else|end|error|fclose|fopen|if|ifdef|ifndef|'
r'include|range|read|render|statistics|switch|undef|version|'
r'warning|while|write|define|macro|local|declare)',
Comment.Preproc),
(r'\b(aa_level|aa_threshold|abs|acos|acosh|adaptive|adc_bailout|'
r'agate|agate_turb|all|alpha|ambient|ambient_light|angle|'
r'aperture|arc_angle|area_light|asc|asin|asinh|assumed_gamma|'
r'atan|atan2|atanh|atmosphere|atmospheric_attenuation|'
r'attenuating|average|background|black_hole|blue|blur_samples|'
r'bounded_by|box_mapping|bozo|break|brick|brick_size|'
r'brightness|brilliance|bumps|bumpy1|bumpy2|bumpy3|bump_map|'
r'bump_size|case|caustics|ceil|checker|chr|clipped_by|clock|'
r'color|color_map|colour|colour_map|component|composite|concat|'
r'confidence|conic_sweep|constant|control0|control1|cos|cosh|'
r'count|crackle|crand|cube|cubic_spline|cylindrical_mapping|'
r'debug|declare|default|degrees|dents|diffuse|direction|'
r'distance|distance_maximum|div|dust|dust_type|eccentricity|'
r'else|emitting|end|error|error_bound|exp|exponent|'
r'fade_distance|fade_power|falloff|falloff_angle|false|'
r'file_exists|filter|finish|fisheye|flatness|flip|floor|'
r'focal_point|fog|fog_alt|fog_offset|fog_type|frequency|gif|'
r'global_settings|glowing|gradient|granite|gray_threshold|'
r'green|halo|hexagon|hf_gray_16|hierarchy|hollow|hypercomplex|'
r'if|ifdef|iff|image_map|incidence|include|int|interpolate|'
r'inverse|ior|irid|irid_wavelength|jitter|lambda|leopard|'
r'linear|linear_spline|linear_sweep|location|log|looks_like|'
r'look_at|low_error_factor|mandel|map_type|marble|material_map|'
r'matrix|max|max_intersections|max_iteration|max_trace_level|'
r'max_value|metallic|min|minimum_reuse|mod|mortar|'
r'nearest_count|no|normal|normal_map|no_shadow|number_of_waves|'
r'octaves|off|offset|omega|omnimax|on|once|onion|open|'
r'orthographic|panoramic|pattern1|pattern2|pattern3|'
r'perspective|pgm|phase|phong|phong_size|pi|pigment|'
r'pigment_map|planar_mapping|png|point_at|pot|pow|ppm|'
r'precision|pwr|quadratic_spline|quaternion|quick_color|'
r'quick_colour|quilted|radial|radians|radiosity|radius|rainbow|'
r'ramp_wave|rand|range|reciprocal|recursion_limit|red|'
r'reflection|refraction|render|repeat|rgb|rgbf|rgbft|rgbt|'
r'right|ripples|rotate|roughness|samples|scale|scallop_wave|'
r'scattering|seed|shadowless|sin|sine_wave|sinh|sky|sky_sphere|'
r'slice|slope_map|smooth|specular|spherical_mapping|spiral|'
r'spiral1|spiral2|spotlight|spotted|sqr|sqrt|statistics|str|'
r'strcmp|strength|strlen|strlwr|strupr|sturm|substr|switch|sys|'
r't|tan|tanh|test_camera_1|test_camera_2|test_camera_3|'
r'test_camera_4|texture|texture_map|tga|thickness|threshold|'
r'tightness|tile2|tiles|track|transform|translate|transmit|'
r'triangle_wave|true|ttf|turbulence|turb_depth|type|'
r'ultra_wide_angle|up|use_color|use_colour|use_index|u_steps|'
r'val|variance|vaxis_rotate|vcross|vdot|version|vlength|'
r'vnormalize|volume_object|volume_rendered|vol_with_light|'
r'vrotate|v_steps|warning|warp|water_level|waves|while|width|'
r'wood|wrinkles|yes)\b', Keyword),
(r'bicubic_patch|blob|box|camera|cone|cubic|cylinder|difference|'
r'disc|height_field|intersection|julia_fractal|lathe|'
r'light_source|merge|mesh|object|plane|poly|polygon|prism|'
r'quadric|quartic|smooth_triangle|sor|sphere|superellipsoid|'
r'text|torus|triangle|union', Name.Builtin),
# TODO: <=, etc
(r'[\[\](){}<>;,]', Punctuation),
(r'[-+*/=]', Operator),
(r'\b(x|y|z|u|v)\b', Name.Builtin.Pseudo),
(r'[a-zA-Z_][a-zA-Z_0-9]*', Name),
(r'[0-9]+\.[0-9]*', Number.Float),
(r'\.[0-9]+', Number.Float),
(r'[0-9]+', Number.Integer),
(r'\s+', Text),
]
}
class AppleScriptLexer(RegexLexer):
"""
For `AppleScript source code
<http://developer.apple.com/documentation/AppleScript/
Conceptual/AppleScriptLangGuide>`_,
including `AppleScript Studio
<http://developer.apple.com/documentation/AppleScript/
Reference/StudioReference>`_.
Contributed by Andreas Amann <[email protected]>.
"""
name = 'AppleScript'
aliases = ['applescript']
filenames = ['*.applescript']
flags = re.MULTILINE | re.DOTALL
Identifiers = r'[a-zA-Z]\w*'
Literals = ['AppleScript', 'current application', 'false', 'linefeed',
'missing value', 'pi','quote', 'result', 'return', 'space',
'tab', 'text item delimiters', 'true', 'version']
Classes = ['alias ', 'application ', 'boolean ', 'class ', 'constant ',
'date ', 'file ', 'integer ', 'list ', 'number ', 'POSIX file ',
'real ', 'record ', 'reference ', 'RGB color ', 'script ',
'text ', 'unit types', '(Unicode )?text', 'string']
BuiltIn = ['attachment', 'attribute run', 'character', 'day', 'month',
'paragraph', 'word', 'year']
HandlerParams = ['about', 'above', 'against', 'apart from', 'around',
'aside from', 'at', 'below', 'beneath', 'beside',
'between', 'for', 'given', 'instead of', 'on', 'onto',
'out of', 'over', 'since']
Commands = ['ASCII (character|number)', 'activate', 'beep', 'choose URL',
'choose application', 'choose color', 'choose file( name)?',
'choose folder', 'choose from list',
'choose remote application', 'clipboard info',
'close( access)?', 'copy', 'count', 'current date', 'delay',
'delete', 'display (alert|dialog)', 'do shell script',
'duplicate', 'exists', 'get eof', 'get volume settings',
'info for', 'launch', 'list (disks|folder)', 'load script',
'log', 'make', 'mount volume', 'new', 'offset',
'open( (for access|location))?', 'path to', 'print', 'quit',
'random number', 'read', 'round', 'run( script)?',
'say', 'scripting components',
'set (eof|the clipboard to|volume)', 'store script',
'summarize', 'system attribute', 'system info',
'the clipboard', 'time to GMT', 'write', 'quoted form']
References = ['(in )?back of', '(in )?front of', '[0-9]+(st|nd|rd|th)',
'first', 'second', 'third', 'fourth', 'fifth', 'sixth',
'seventh', 'eighth', 'ninth', 'tenth', 'after', 'back',
'before', 'behind', 'every', 'front', 'index', 'last',
'middle', 'some', 'that', 'through', 'thru', 'where', 'whose']
Operators = ["and", "or", "is equal", "equals", "(is )?equal to", "is not",
"isn't", "isn't equal( to)?", "is not equal( to)?",
"doesn't equal", "does not equal", "(is )?greater than",
"comes after", "is not less than or equal( to)?",
"isn't less than or equal( to)?", "(is )?less than",
"comes before", "is not greater than or equal( to)?",
"isn't greater than or equal( to)?",
"(is )?greater than or equal( to)?", "is not less than",
"isn't less than", "does not come before",
"doesn't come before", "(is )?less than or equal( to)?",
"is not greater than", "isn't greater than",
"does not come after", "doesn't come after", "starts? with",
"begins? with", "ends? with", "contains?", "does not contain",
"doesn't contain", "is in", "is contained by", "is not in",
"is not contained by", "isn't contained by", "div", "mod",
"not", "(a )?(ref( to)?|reference to)", "is", "does"]
Control = ['considering', 'else', 'error', 'exit', 'from', 'if',
'ignoring', 'in', 'repeat', 'tell', 'then', 'times', 'to',
'try', 'until', 'using terms from', 'while', 'whith',
'with timeout( of)?', 'with transaction', 'by', 'continue',
'end', 'its?', 'me', 'my', 'return', 'of' , 'as']
Declarations = ['global', 'local', 'prop(erty)?', 'set', 'get']
Reserved = ['but', 'put', 'returning', 'the']
StudioClasses = ['action cell', 'alert reply', 'application', 'box',
'browser( cell)?', 'bundle', 'button( cell)?', 'cell',
'clip view', 'color well', 'color-panel',
'combo box( item)?', 'control',
'data( (cell|column|item|row|source))?', 'default entry',
'dialog reply', 'document', 'drag info', 'drawer',
'event', 'font(-panel)?', 'formatter',
'image( (cell|view))?', 'matrix', 'menu( item)?', 'item',
'movie( view)?', 'open-panel', 'outline view', 'panel',
'pasteboard', 'plugin', 'popup button',
'progress indicator', 'responder', 'save-panel',
'scroll view', 'secure text field( cell)?', 'slider',
'sound', 'split view', 'stepper', 'tab view( item)?',
'table( (column|header cell|header view|view))',
'text( (field( cell)?|view))?', 'toolbar( item)?',
'user-defaults', 'view', 'window']
StudioEvents = ['accept outline drop', 'accept table drop', 'action',
'activated', 'alert ended', 'awake from nib', 'became key',
'became main', 'begin editing', 'bounds changed',
'cell value', 'cell value changed', 'change cell value',
'change item value', 'changed', 'child of item',
'choose menu item', 'clicked', 'clicked toolbar item',
'closed', 'column clicked', 'column moved',
'column resized', 'conclude drop', 'data representation',
'deminiaturized', 'dialog ended', 'document nib name',
'double clicked', 'drag( (entered|exited|updated))?',
'drop', 'end editing', 'exposed', 'idle', 'item expandable',
'item value', 'item value changed', 'items changed',
'keyboard down', 'keyboard up', 'launched',
'load data representation', 'miniaturized', 'mouse down',
'mouse dragged', 'mouse entered', 'mouse exited',
'mouse moved', 'mouse up', 'moved',
'number of browser rows', 'number of items',
'number of rows', 'open untitled', 'opened', 'panel ended',
'parameters updated', 'plugin loaded', 'prepare drop',
'prepare outline drag', 'prepare outline drop',
'prepare table drag', 'prepare table drop',
'read from file', 'resigned active', 'resigned key',
'resigned main', 'resized( sub views)?',
'right mouse down', 'right mouse dragged',
'right mouse up', 'rows changed', 'scroll wheel',
'selected tab view item', 'selection changed',
'selection changing', 'should begin editing',
'should close', 'should collapse item',
'should end editing', 'should expand item',
'should open( untitled)?',
'should quit( after last window closed)?',
'should select column', 'should select item',
'should select row', 'should select tab view item',
'should selection change', 'should zoom', 'shown',
'update menu item', 'update parameters',
'update toolbar item', 'was hidden', 'was miniaturized',
'will become active', 'will close', 'will dismiss',
'will display browser cell', 'will display cell',
'will display item cell', 'will display outline cell',
'will finish launching', 'will hide', 'will miniaturize',
'will move', 'will open', 'will pop up', 'will quit',
'will resign active', 'will resize( sub views)?',
'will select tab view item', 'will show', 'will zoom',
'write to file', 'zoomed']
StudioCommands = ['animate', 'append', 'call method', 'center',
'close drawer', 'close panel', 'display',
'display alert', 'display dialog', 'display panel', 'go',
'hide', 'highlight', 'increment', 'item for',
'load image', 'load movie', 'load nib', 'load panel',
'load sound', 'localized string', 'lock focus', 'log',
'open drawer', 'path for', 'pause', 'perform action',
'play', 'register', 'resume', 'scroll', 'select( all)?',
'show', 'size to fit', 'start', 'step back',
'step forward', 'stop', 'synchronize', 'unlock focus',
'update']
StudioProperties = ['accepts arrow key', 'action method', 'active',
'alignment', 'allowed identifiers',
'allows branch selection', 'allows column reordering',
'allows column resizing', 'allows column selection',
'allows customization',
'allows editing text attributes',
'allows empty selection', 'allows mixed state',
'allows multiple selection', 'allows reordering',
'allows undo', 'alpha( value)?', 'alternate image',
'alternate increment value', 'alternate title',
'animation delay', 'associated file name',
'associated object', 'auto completes', 'auto display',
'auto enables items', 'auto repeat',
'auto resizes( outline column)?',
'auto save expanded items', 'auto save name',
'auto save table columns', 'auto saves configuration',
'auto scroll', 'auto sizes all columns to fit',
'auto sizes cells', 'background color', 'bezel state',
'bezel style', 'bezeled', 'border rect', 'border type',
'bordered', 'bounds( rotation)?', 'box type',
'button returned', 'button type',
'can choose directories', 'can choose files',
'can draw', 'can hide',
'cell( (background color|size|type))?', 'characters',
'class', 'click count', 'clicked( data)? column',
'clicked data item', 'clicked( data)? row',
'closeable', 'collating', 'color( (mode|panel))',
'command key down', 'configuration',
'content(s| (size|view( margins)?))?', 'context',
'continuous', 'control key down', 'control size',
'control tint', 'control view',
'controller visible', 'coordinate system',
'copies( on scroll)?', 'corner view', 'current cell',
'current column', 'current( field)? editor',
'current( menu)? item', 'current row',
'current tab view item', 'data source',
'default identifiers', 'delta (x|y|z)',
'destination window', 'directory', 'display mode',
'displayed cell', 'document( (edited|rect|view))?',
'double value', 'dragged column', 'dragged distance',
'dragged items', 'draws( cell)? background',
'draws grid', 'dynamically scrolls', 'echos bullets',
'edge', 'editable', 'edited( data)? column',
'edited data item', 'edited( data)? row', 'enabled',
'enclosing scroll view', 'ending page',
'error handling', 'event number', 'event type',
'excluded from windows menu', 'executable path',
'expanded', 'fax number', 'field editor', 'file kind',
'file name', 'file type', 'first responder',
'first visible column', 'flipped', 'floating',
'font( panel)?', 'formatter', 'frameworks path',
'frontmost', 'gave up', 'grid color', 'has data items',
'has horizontal ruler', 'has horizontal scroller',
'has parent data item', 'has resize indicator',
'has shadow', 'has sub menu', 'has vertical ruler',
'has vertical scroller', 'header cell', 'header view',
'hidden', 'hides when deactivated', 'highlights by',
'horizontal line scroll', 'horizontal page scroll',
'horizontal ruler view', 'horizontally resizable',
'icon image', 'id', 'identifier',
'ignores multiple clicks',
'image( (alignment|dims when disabled|frame style|'
'scaling))?',
'imports graphics', 'increment value',
'indentation per level', 'indeterminate', 'index',
'integer value', 'intercell spacing', 'item height',
'key( (code|equivalent( modifier)?|window))?',
'knob thickness', 'label', 'last( visible)? column',
'leading offset', 'leaf', 'level', 'line scroll',
'loaded', 'localized sort', 'location', 'loop mode',
'main( (bunde|menu|window))?', 'marker follows cell',
'matrix mode', 'maximum( content)? size',
'maximum visible columns',
'menu( form representation)?', 'miniaturizable',
'miniaturized', 'minimized image', 'minimized title',
'minimum column width', 'minimum( content)? size',
'modal', 'modified', 'mouse down state',
'movie( (controller|file|rect))?', 'muted', 'name',
'needs display', 'next state', 'next text',
'number of tick marks', 'only tick mark values',
'opaque', 'open panel', 'option key down',
'outline table column', 'page scroll', 'pages across',
'pages down', 'palette label', 'pane splitter',
'parent data item', 'parent window', 'pasteboard',
'path( (names|separator))?', 'playing',
'plays every frame', 'plays selection only', 'position',
'preferred edge', 'preferred type', 'pressure',
'previous text', 'prompt', 'properties',
'prototype cell', 'pulls down', 'rate',
'released when closed', 'repeated',
'requested print time', 'required file type',
'resizable', 'resized column', 'resource path',
'returns records', 'reuses columns', 'rich text',
'roll over', 'row height', 'rulers visible',
'save panel', 'scripts path', 'scrollable',
'selectable( identifiers)?', 'selected cell',
'selected( data)? columns?', 'selected data items?',
'selected( data)? rows?', 'selected item identifier',
'selection by rect', 'send action on arrow key',
'sends action when done editing', 'separates columns',
'separator item', 'sequence number', 'services menu',
'shared frameworks path', 'shared support path',
'sheet', 'shift key down', 'shows alpha',
'shows state by', 'size( mode)?',
'smart insert delete enabled', 'sort case sensitivity',
'sort column', 'sort order', 'sort type',
'sorted( data rows)?', 'sound', 'source( mask)?',
'spell checking enabled', 'starting page', 'state',
'string value', 'sub menu', 'super menu', 'super view',
'tab key traverses cells', 'tab state', 'tab type',
'tab view', 'table view', 'tag', 'target( printer)?',
'text color', 'text container insert',
'text container origin', 'text returned',
'tick mark position', 'time stamp',
'title(d| (cell|font|height|position|rect))?',
'tool tip', 'toolbar', 'trailing offset', 'transparent',
'treat packages as directories', 'truncated labels',
'types', 'unmodified characters', 'update views',
'use sort indicator', 'user defaults',
'uses data source', 'uses ruler',
'uses threaded animation',
'uses title from previous column', 'value wraps',
'version',
'vertical( (line scroll|page scroll|ruler view))?',
'vertically resizable', 'view',
'visible( document rect)?', 'volume', 'width', 'window',
'windows menu', 'wraps', 'zoomable', 'zoomed']
tokens = {
'root': [
(r'\s+', Text),
(ur'¬\n', String.Escape),
(r"'s\s+", Text), # This is a possessive, consider moving
(r'(--|#).*?$', Comment),
(r'\(\*', Comment.Multiline, 'comment'),
(r'[\(\){}!,.:]', Punctuation),
(ur'(«)([^»]+)(»)',
bygroups(Text, Name.Builtin, Text)),
(r'\b((?:considering|ignoring)\s*)'
r'(application responses|case|diacriticals|hyphens|'
r'numeric strings|punctuation|white space)',
bygroups(Keyword, Name.Builtin)),
(ur'(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|/|÷|\^)', Operator),
(r"\b(%s)\b" % '|'.join(Operators), Operator.Word),
(r'^(\s*(?:on|end)\s+)'
r'(%s)' % '|'.join(StudioEvents),
bygroups(Keyword, Name.Function)),
(r'^(\s*)(in|on|script|to)(\s+)', bygroups(Text, Keyword, Text)),
(r'\b(as )(%s)\b' % '|'.join(Classes),
bygroups(Keyword, Name.Class)),
(r'\b(%s)\b' % '|'.join(Literals), Name.Constant),
(r'\b(%s)\b' % '|'.join(Commands), Name.Builtin),
(r'\b(%s)\b' % '|'.join(Control), Keyword),
(r'\b(%s)\b' % '|'.join(Declarations), Keyword),
(r'\b(%s)\b' % '|'.join(Reserved), Name.Builtin),
(r'\b(%s)s?\b' % '|'.join(BuiltIn), Name.Builtin),
(r'\b(%s)\b' % '|'.join(HandlerParams), Name.Builtin),
(r'\b(%s)\b' % '|'.join(StudioProperties), Name.Attribute),
(r'\b(%s)s?\b' % '|'.join(StudioClasses), Name.Builtin),
(r'\b(%s)\b' % '|'.join(StudioCommands), Name.Builtin),
(r'\b(%s)\b' % '|'.join(References), Name.Builtin),
(r'"(\\\\|\\"|[^"])*"', String.Double),
(r'\b(%s)\b' % Identifiers, Name.Variable),
(r'[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?', Number.Float),
(r'[-+]?\d+', Number.Integer),
],
'comment': [
('\(\*', Comment.Multiline, '#push'),
('\*\)', Comment.Multiline, '#pop'),
('[^*(]+', Comment.Multiline),
('[*(]', Comment.Multiline),
],
}
class ModelicaLexer(RegexLexer):
"""
For `Modelica <http://www.modelica.org/>`_ source code.
*New in Pygments 1.1.*
"""
name = 'Modelica'
aliases = ['modelica']
filenames = ['*.mo']
mimetypes = ['text/x-modelica']
flags = re.IGNORECASE | re.DOTALL
tokens = {
'whitespace': [
(r'\n', Text),
(r'\s+', Text),
(r'\\\n', Text), # line continuation
(r'//(\n|(.|\n)*?[^\\]\n)', Comment),
(r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment),
],
'statements': [
(r'"', String, 'string'),
(r'(\d+\.\d*|\.\d+|\d+|\d.)[eE][+-]?\d+[lL]?', Number.Float),
(r'(\d+\.\d*|\.\d+)', Number.Float),
(r'\d+[Ll]?', Number.Integer),
(r'[~!%^&*+=|?:<>/-]', Operator),
(r'[()\[\]{},.;]', Punctuation),
(r'(true|false|NULL|Real|Integer|Boolean)\b', Name.Builtin),
(r"([a-zA-Z_][\w]*|'[a-zA-Z_\+\-\*\/\^][\w]*')"
r"(\.([a-zA-Z_][\w]*|'[a-zA-Z_\+\-\*\/\^][\w]*'))+", Name.Class),
(r"('[\w\+\-\*\/\^]+'|\w+)", Name) ],
'root': [
include('whitespace'),
include('keywords'),
include('functions'),
include('operators'),
include('classes'),
(r'("<html>|<html>)', Name.Tag, 'html-content'),
include('statements')
],
'keywords': [
(r'(algorithm|annotation|break|connect|constant|constrainedby|'
r'discrete|each|else|elseif|elsewhen|encapsulated|enumeration|'
r'end|equation|exit|expandable|extends|'
r'external|false|final|flow|for|if|import|in|inner|input|'
r'loop|nondiscrete|outer|output|parameter|partial|'
r'protected|public|redeclare|replaceable|stream|time|then|true|'
r'when|while|within)\b', Keyword)
],
'functions': [
(r'(abs|acos|acosh|asin|asinh|atan|atan2|atan3|ceil|cos|cosh|'
r'cross|div|exp|floor|log|log10|mod|rem|sign|sin|sinh|size|'
r'sqrt|tan|tanh|zeros)\b', Name.Function)
],
'operators': [
(r'(and|assert|cardinality|change|delay|der|edge|initial|'
r'noEvent|not|or|pre|reinit|return|sample|smooth|'
r'terminal|terminate)\b', Name.Builtin)
],
'classes': [
(r'(block|class|connector|function|model|package|'
r'record|type)\b', Name.Class)
],
'string': [
(r'"', String, '#pop'),
(r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})',
String.Escape),
(r'[^\\"\n]+', String), # all other characters
(r'\\\n', String), # line continuation
(r'\\', String) # stray backslash
],
'html-content': [
(r'<\s*/\s*html\s*>', Name.Tag, '#pop'),
(r'.+?(?=<\s*/\s*html\s*>)', using(HtmlLexer)),
]
}
class RebolLexer(RegexLexer):
"""
A `REBOL <http://www.rebol.com/>`_ lexer.
*New in Pygments 1.1.*
"""
name = 'REBOL'
aliases = ['rebol']
filenames = ['*.r', '*.r3']
mimetypes = ['text/x-rebol']
flags = re.IGNORECASE | re.MULTILINE
re.IGNORECASE
escape_re = r'(?:\^\([0-9a-fA-F]{1,4}\)*)'
def word_callback(lexer, match):
word = match.group()
if re.match(".*:$", word):
yield match.start(), Generic.Subheading, word
elif re.match(
r'(native|alias|all|any|as-string|as-binary|bind|bound\?|case|'
r'catch|checksum|comment|debase|dehex|exclude|difference|disarm|'
r'either|else|enbase|foreach|remove-each|form|free|get|get-env|if|'
r'in|intersect|loop|minimum-of|maximum-of|mold|new-line|'
r'new-line\?|not|now|prin|print|reduce|compose|construct|repeat|'
r'reverse|save|script\?|set|shift|switch|throw|to-hex|trace|try|'
r'type\?|union|unique|unless|unprotect|unset|until|use|value\?|'
r'while|compress|decompress|secure|open|close|read|read-io|'
r'write-io|write|update|query|wait|input\?|exp|log-10|log-2|'
r'log-e|square-root|cosine|sine|tangent|arccosine|arcsine|'
r'arctangent|protect|lowercase|uppercase|entab|detab|connected\?|'
r'browse|launch|stats|get-modes|set-modes|to-local-file|'
r'to-rebol-file|encloak|decloak|create-link|do-browser|bind\?|'
r'hide|draw|show|size-text|textinfo|offset-to-caret|'
r'caret-to-offset|local-request-file|rgb-to-hsv|hsv-to-rgb|'
r'crypt-strength\?|dh-make-key|dh-generate-key|dh-compute-key|'
r'dsa-make-key|dsa-generate-key|dsa-make-signature|'
r'dsa-verify-signature|rsa-make-key|rsa-generate-key|'
r'rsa-encrypt)$', word):
yield match.start(), Name.Builtin, word
elif re.match(
r'(add|subtract|multiply|divide|remainder|power|and~|or~|xor~|'
r'minimum|maximum|negate|complement|absolute|random|head|tail|'
r'next|back|skip|at|pick|first|second|third|fourth|fifth|sixth|'
r'seventh|eighth|ninth|tenth|last|path|find|select|make|to|copy\*|'
r'insert|remove|change|poke|clear|trim|sort|min|max|abs|cp|'
r'copy)$', word):
yield match.start(), Name.Function, word
elif re.match(
r'(error|source|input|license|help|install|echo|Usage|with|func|'
r'throw-on-error|function|does|has|context|probe|\?\?|as-pair|'
r'mod|modulo|round|repend|about|set-net|append|join|rejoin|reform|'
r'remold|charset|array|replace|move|extract|forskip|forall|alter|'
r'first+|also|take|for|forever|dispatch|attempt|what-dir|'
r'change-dir|clean-path|list-dir|dirize|rename|split-path|delete|'
r'make-dir|delete-dir|in-dir|confirm|dump-obj|upgrade|what|'
r'build-tag|process-source|build-markup|decode-cgi|read-cgi|'
r'write-user|save-user|set-user-name|protect-system|parse-xml|'
r'cvs-date|cvs-version|do-boot|get-net-info|desktop|layout|'
r'scroll-para|get-face|alert|set-face|uninstall|unfocus|'
r'request-dir|center-face|do-events|net-error|decode-url|'
r'parse-header|parse-header-date|parse-email-addrs|import-email|'
r'send|build-attach-body|resend|show-popup|hide-popup|open-events|'
r'find-key-face|do-face|viewtop|confine|find-window|'
r'insert-event-func|remove-event-func|inform|dump-pane|dump-face|'
r'flag-face|deflag-face|clear-fields|read-net|vbug|path-thru|'
r'read-thru|load-thru|do-thru|launch-thru|load-image|'
r'request-download|do-face-alt|set-font|set-para|get-style|'
r'set-style|make-face|stylize|choose|hilight-text|hilight-all|'
r'unlight-text|focus|scroll-drag|clear-face|reset-face|scroll-face|'
r'resize-face|load-stock|load-stock-block|notify|request|flash|'
r'request-color|request-pass|request-text|request-list|'
r'request-date|request-file|dbug|editor|link-relative-path|'
r'emailer|parse-error)$', word):
yield match.start(), Keyword.Namespace, word
elif re.match(
r'(halt|quit|do|load|q|recycle|call|run|ask|parse|view|unview|'
r'return|exit|break)$', word):
yield match.start(), Name.Exception, word
elif re.match('REBOL$', word):
yield match.start(), Generic.Heading, word
elif re.match("to-.*", word):
yield match.start(), Keyword, word
elif re.match('(\+|-|\*|/|//|\*\*|and|or|xor|=\?|=|==|<>|<|>|<=|>=)$',
word):
yield match.start(), Operator, word
elif re.match(".*\?$", word):
yield match.start(), Keyword, word
elif re.match(".*\!$", word):
yield match.start(), Keyword.Type, word
elif re.match("'.*", word):
yield match.start(), Name.Variable.Instance, word # lit-word
elif re.match("#.*", word):
yield match.start(), Name.Label, word # issue
elif re.match("%.*", word):
yield match.start(), Name.Decorator, word # file
else:
yield match.start(), Name.Variable, word
tokens = {
'root': [
(r'\s+', Text),
(r'#"', String.Char, 'char'),
(r'#{[0-9a-fA-F]*}', Number.Hex),
(r'2#{', Number.Hex, 'bin2'),
(r'64#{[0-9a-zA-Z+/=\s]*}', Number.Hex),
(r'"', String, 'string'),
(r'{', String, 'string2'),
(r';#+.*\n', Comment.Special),
(r';\*+.*\n', Comment.Preproc),
(r';.*\n', Comment),
(r'%"', Name.Decorator, 'stringFile'),
(r'%[^(\^{^")\s\[\]]+', Name.Decorator),
(r'<[a-zA-Z0-9:._-]*>', Name.Tag),
(r'<[^(<>\s")]+', Name.Tag, 'tag'),
(r'[+-]?([a-zA-Z]{1,3})?\$\d+(\.\d+)?', Number.Float), # money
(r'[+-]?\d+\:\d+(\:\d+)?(\.\d+)?', String.Other), # time
(r'\d+\-[0-9a-zA-Z]+\-\d+(\/\d+\:\d+(\:\d+)?'
r'([\.\d+]?([+-]?\d+:\d+)?)?)?', String.Other), # date
(r'\d+(\.\d+)+\.\d+', Keyword.Constant), # tuple
(r'\d+[xX]\d+', Keyword.Constant), # pair
(r'[+-]?\d+(\'\d+)?([\.,]\d*)?[eE][+-]?\d+', Number.Float),
(r'[+-]?\d+(\'\d+)?[\.,]\d*', Number.Float),
(r'[+-]?\d+(\'\d+)?', Number),
(r'[\[\]\(\)]', Generic.Strong),
(r'[a-zA-Z]+[^(\^{"\s:)]*://[^(\^{"\s)]*', Name.Decorator), # url
(r'mailto:[^(\^{"@\s)]+@[^(\^{"@\s)]+', Name.Decorator), # url
(r'[^(\^{"@\s)]+@[^(\^{"@\s)]+', Name.Decorator), # email
(r'comment\s', Comment, 'comment'),
(r'/[^(\^{^")\s/[\]]*', Name.Attribute),
(r'([^(\^{^")\s/[\]]+)(?=[:({"\s/\[\]])', word_callback),
(r'([^(\^{^")\s]+)', Text),
],
'string': [
(r'[^(\^")]+', String),
(escape_re, String.Escape),
(r'[\(|\)]+', String),
(r'\^.', String.Escape),
(r'"', String, '#pop'),
],
'string2': [
(r'[^(\^{^})]+', String),
(escape_re, String.Escape),
(r'[\(|\)]+', String),
(r'\^.', String.Escape),
(r'{', String, '#push'),
(r'}', String, '#pop'),
],
'stringFile': [
(r'[^(\^")]+', Name.Decorator),
(escape_re, Name.Decorator),
(r'\^.', Name.Decorator),
(r'"', Name.Decorator, '#pop'),
],
'char': [
(escape_re + '"', String.Char, '#pop'),
(r'\^."', String.Char, '#pop'),
(r'."', String.Char, '#pop'),
],
'tag': [
(escape_re, Name.Tag),
(r'"', Name.Tag, 'tagString'),
(r'[^(<>\r\n")]+', Name.Tag),
(r'>', Name.Tag, '#pop'),
],
'tagString': [
(r'[^(\^")]+', Name.Tag),
(escape_re, Name.Tag),
(r'[\(|\)]+', Name.Tag),
(r'\^.', Name.Tag),
(r'"', Name.Tag, '#pop'),
],
'tuple': [
(r'(\d+\.)+', Keyword.Constant),
(r'\d+', Keyword.Constant, '#pop'),
],
'bin2': [
(r'\s+', Number.Hex),
(r'([0-1]\s*){8}', Number.Hex),
(r'}', Number.Hex, '#pop'),
],
'comment': [
(r'"', Comment, 'commentString1'),
(r'{', Comment, 'commentString2'),
(r'\[', Comment, 'commentBlock'),
(r'[^(\s{\"\[]+', Comment, '#pop'),
],
'commentString1': [
(r'[^(\^")]+', Comment),
(escape_re, Comment),
(r'[\(|\)]+', Comment),
(r'\^.', Comment),
(r'"', Comment, '#pop'),
],
'commentString2': [
(r'[^(\^{^})]+', Comment),
(escape_re, Comment),
(r'[\(|\)]+', Comment),
(r'\^.', Comment),
(r'{', Comment, '#push'),
(r'}', Comment, '#pop'),
],
'commentBlock': [
(r'\[',Comment, '#push'),
(r'\]',Comment, '#pop'),
(r'[^(\[\])]*', Comment),
],
}
class ABAPLexer(RegexLexer):
"""
Lexer for ABAP, SAP's integrated language.
*New in Pygments 1.1.*
"""
name = 'ABAP'
aliases = ['abap']
filenames = ['*.abap']
mimetypes = ['text/x-abap']
flags = re.IGNORECASE | re.MULTILINE
tokens = {
'common': [
(r'\s+', Text),
(r'^\*.*$', Comment.Single),
(r'\".*?\n', Comment.Single),
],
'variable-names': [
(r'<[\S_]+>', Name.Variable),
(r'[\w][\w_~]*(?:(\[\])|->\*)?', Name.Variable),
],
'root': [
include('common'),
#function calls
(r'(CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION))(\s+)(\'?\S+\'?)',
bygroups(Keyword, Text, Name.Function)),
(r'(CALL\s+(?:DIALOG|SCREEN|SUBSCREEN|SELECTION-SCREEN|'
r'TRANSACTION|TRANSFORMATION))\b',
Keyword),
(r'(FORM|PERFORM)(\s+)([\w_]+)',
bygroups(Keyword, Text, Name.Function)),
(r'(PERFORM)(\s+)(\()([\w_]+)(\))',
bygroups(Keyword, Text, Punctuation, Name.Variable, Punctuation )),
(r'(MODULE)(\s+)(\S+)(\s+)(INPUT|OUTPUT)',
bygroups(Keyword, Text, Name.Function, Text, Keyword)),
# method implementation
(r'(METHOD)(\s+)([\w_~]+)',
bygroups(Keyword, Text, Name.Function)),
# method calls
(r'(\s+)([\w_\-]+)([=\-]>)([\w_\-~]+)',
bygroups(Text, Name.Variable, Operator, Name.Function)),
# call methodnames returning style
(r'(?<=(=|-)>)([\w_\-~]+)(?=\()', Name.Function),
# keywords with dashes in them.
# these need to be first, because for instance the -ID part
# of MESSAGE-ID wouldn't get highlighted if MESSAGE was
# first in the list of keywords.
(r'(ADD-CORRESPONDING|AUTHORITY-CHECK|'
r'CLASS-DATA|CLASS-EVENTS|CLASS-METHODS|CLASS-POOL|'
r'DELETE-ADJACENT|DIVIDE-CORRESPONDING|'
r'EDITOR-CALL|ENHANCEMENT-POINT|ENHANCEMENT-SECTION|EXIT-COMMAND|'
r'FIELD-GROUPS|FIELD-SYMBOLS|FUNCTION-POOL|'
r'INTERFACE-POOL|INVERTED-DATE|'
r'LOAD-OF-PROGRAM|LOG-POINT|'
r'MESSAGE-ID|MOVE-CORRESPONDING|MULTIPLY-CORRESPONDING|'
r'NEW-LINE|NEW-PAGE|NEW-SECTION|NO-EXTENSION|'
r'OUTPUT-LENGTH|PRINT-CONTROL|'
r'SELECT-OPTIONS|START-OF-SELECTION|SUBTRACT-CORRESPONDING|'
r'SYNTAX-CHECK|SYSTEM-EXCEPTIONS|'
r'TYPE-POOL|TYPE-POOLS'
r')\b', Keyword),
# keyword kombinations
(r'CREATE\s+(PUBLIC|PRIVATE|DATA|OBJECT)|'
r'((PUBLIC|PRIVATE|PROTECTED)\s+SECTION|'
r'(TYPE|LIKE)(\s+(LINE\s+OF|REF\s+TO|'
r'(SORTED|STANDARD|HASHED)\s+TABLE\s+OF))?|'
r'FROM\s+(DATABASE|MEMORY)|CALL\s+METHOD|'
r'(GROUP|ORDER) BY|HAVING|SEPARATED BY|'
r'GET\s+(BADI|BIT|CURSOR|DATASET|LOCALE|PARAMETER|'
r'PF-STATUS|(PROPERTY|REFERENCE)\s+OF|'
r'RUN\s+TIME|TIME\s+(STAMP)?)?|'
r'SET\s+(BIT|BLANK\s+LINES|COUNTRY|CURSOR|DATASET|EXTENDED\s+CHECK|'
r'HANDLER|HOLD\s+DATA|LANGUAGE|LEFT\s+SCROLL-BOUNDARY|'
r'LOCALE|MARGIN|PARAMETER|PF-STATUS|PROPERTY\s+OF|'
r'RUN\s+TIME\s+(ANALYZER|CLOCK\s+RESOLUTION)|SCREEN|'
r'TITLEBAR|UPADTE\s+TASK\s+LOCAL|USER-COMMAND)|'
r'CONVERT\s+((INVERTED-)?DATE|TIME|TIME\s+STAMP|TEXT)|'
r'(CLOSE|OPEN)\s+(DATASET|CURSOR)|'
r'(TO|FROM)\s+(DATA BUFFER|INTERNAL TABLE|MEMORY ID|'
r'DATABASE|SHARED\s+(MEMORY|BUFFER))|'
r'DESCRIBE\s+(DISTANCE\s+BETWEEN|FIELD|LIST|TABLE)|'
r'FREE\s(MEMORY|OBJECT)?|'
r'PROCESS\s+(BEFORE\s+OUTPUT|AFTER\s+INPUT|'
r'ON\s+(VALUE-REQUEST|HELP-REQUEST))|'
r'AT\s+(LINE-SELECTION|USER-COMMAND|END\s+OF|NEW)|'
r'AT\s+SELECTION-SCREEN(\s+(ON(\s+(BLOCK|(HELP|VALUE)-REQUEST\s+FOR|'
r'END\s+OF|RADIOBUTTON\s+GROUP))?|OUTPUT))?|'
r'SELECTION-SCREEN:?\s+((BEGIN|END)\s+OF\s+((TABBED\s+)?BLOCK|LINE|'
r'SCREEN)|COMMENT|FUNCTION\s+KEY|'
r'INCLUDE\s+BLOCKS|POSITION|PUSHBUTTON|'
r'SKIP|ULINE)|'
r'LEAVE\s+(LIST-PROCESSING|PROGRAM|SCREEN|'
r'TO LIST-PROCESSING|TO TRANSACTION)'
r'(ENDING|STARTING)\s+AT|'
r'FORMAT\s+(COLOR|INTENSIFIED|INVERSE|HOTSPOT|INPUT|FRAMES|RESET)|'
r'AS\s+(CHECKBOX|SUBSCREEN|WINDOW)|'
r'WITH\s+(((NON-)?UNIQUE)?\s+KEY|FRAME)|'
r'(BEGIN|END)\s+OF|'
r'DELETE(\s+ADJACENT\s+DUPLICATES\sFROM)?|'
r'COMPARING(\s+ALL\s+FIELDS)?|'
r'INSERT(\s+INITIAL\s+LINE\s+INTO|\s+LINES\s+OF)?|'
r'IN\s+((BYTE|CHARACTER)\s+MODE|PROGRAM)|'
r'END-OF-(DEFINITION|PAGE|SELECTION)|'
r'WITH\s+FRAME(\s+TITLE)|'
# simple kombinations
r'AND\s+(MARK|RETURN)|CLIENT\s+SPECIFIED|CORRESPONDING\s+FIELDS\s+OF|'
r'IF\s+FOUND|FOR\s+EVENT|INHERITING\s+FROM|LEAVE\s+TO\s+SCREEN|'
r'LOOP\s+AT\s+(SCREEN)?|LOWER\s+CASE|MATCHCODE\s+OBJECT|MODIF\s+ID|'
r'MODIFY\s+SCREEN|NESTING\s+LEVEL|NO\s+INTERVALS|OF\s+STRUCTURE|'
r'RADIOBUTTON\s+GROUP|RANGE\s+OF|REF\s+TO|SUPPRESS DIALOG|'
r'TABLE\s+OF|UPPER\s+CASE|TRANSPORTING\s+NO\s+FIELDS|'
r'VALUE\s+CHECK|VISIBLE\s+LENGTH|HEADER\s+LINE)\b', Keyword),
# single word keywords.
(r'(^|(?<=(\s|\.)))(ABBREVIATED|ADD|ALIASES|APPEND|ASSERT|'
r'ASSIGN(ING)?|AT(\s+FIRST)?|'
r'BACK|BLOCK|BREAK-POINT|'
r'CASE|CATCH|CHANGING|CHECK|CLASS|CLEAR|COLLECT|COLOR|COMMIT|'
r'CREATE|COMMUNICATION|COMPONENTS?|COMPUTE|CONCATENATE|CONDENSE|'
r'CONSTANTS|CONTEXTS|CONTINUE|CONTROLS|'
r'DATA|DECIMALS|DEFAULT|DEFINE|DEFINITION|DEFERRED|DEMAND|'
r'DETAIL|DIRECTORY|DIVIDE|DO|'
r'ELSE(IF)?|ENDAT|ENDCASE|ENDCLASS|ENDDO|ENDFORM|ENDFUNCTION|'
r'ENDIF|ENDLOOP|ENDMETHOD|ENDMODULE|ENDSELECT|ENDTRY|'
r'ENHANCEMENT|EVENTS|EXCEPTIONS|EXIT|EXPORT|EXPORTING|EXTRACT|'
r'FETCH|FIELDS?|FIND|FOR|FORM|FORMAT|FREE|FROM|'
r'HIDE|'
r'ID|IF|IMPORT|IMPLEMENTATION|IMPORTING|IN|INCLUDE|INCLUDING|'
r'INDEX|INFOTYPES|INITIALIZATION|INTERFACE|INTERFACES|INTO|'
r'LENGTH|LINES|LOAD|LOCAL|'
r'JOIN|'
r'KEY|'
r'MAXIMUM|MESSAGE|METHOD[S]?|MINIMUM|MODULE|MODIFY|MOVE|MULTIPLY|'
r'NODES|'
r'OBLIGATORY|OF|OFF|ON|OVERLAY|'
r'PACK|PARAMETERS|PERCENTAGE|POSITION|PROGRAM|PROVIDE|PUBLIC|PUT|'
r'RAISE|RAISING|RANGES|READ|RECEIVE|REFRESH|REJECT|REPORT|RESERVE|'
r'RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|'
r'SCROLL|SEARCH|SELECT|SHIFT|SINGLE|SKIP|SORT|SPLIT|STATICS|STOP|'
r'SUBMIT|SUBTRACT|SUM|SUMMARY|SUMMING|SUPPLY|'
r'TABLE|TABLES|TIMES|TITLE|TO|TOP-OF-PAGE|TRANSFER|TRANSLATE|TRY|TYPES|'
r'ULINE|UNDER|UNPACK|UPDATE|USING|'
r'VALUE|VALUES|VIA|'
r'WAIT|WHEN|WHERE|WHILE|WITH|WINDOW|WRITE)\b', Keyword),
# builtins
(r'(abs|acos|asin|atan|'
r'boolc|boolx|bit_set|'
r'char_off|charlen|ceil|cmax|cmin|condense|contains|'
r'contains_any_of|contains_any_not_of|concat_lines_of|cos|cosh|'
r'count|count_any_of|count_any_not_of|'
r'dbmaxlen|distance|'
r'escape|exp|'
r'find|find_end|find_any_of|find_any_not_of|floor|frac|from_mixed|'
r'insert|'
r'lines|log|log10|'
r'match|matches|'
r'nmax|nmin|numofchar|'
r'repeat|replace|rescale|reverse|round|'
r'segment|shift_left|shift_right|sign|sin|sinh|sqrt|strlen|'
r'substring|substring_after|substring_from|substring_before|substring_to|'
r'tan|tanh|to_upper|to_lower|to_mixed|translate|trunc|'
r'xstrlen)(\()\b', bygroups(Name.Builtin, Punctuation)),
(r'&[0-9]', Name),
(r'[0-9]+', Number.Integer),
# operators which look like variable names before
# parsing variable names.
(r'(?<=(\s|.))(AND|EQ|NE|GT|LT|GE|LE|CO|CN|CA|NA|CS|NOT|NS|CP|NP|'
r'BYTE-CO|BYTE-CN|BYTE-CA|BYTE-NA|BYTE-CS|BYTE-NS|'
r'IS\s+(NOT\s+)?(INITIAL|ASSIGNED|REQUESTED|BOUND))\b', Operator),
include('variable-names'),
# standard oparators after variable names,
# because < and > are part of field symbols.
(r'[?*<>=\-+]', Operator),
(r"'(''|[^'])*'", String.Single),
(r'[/;:()\[\],\.]', Punctuation)
],
}
class NewspeakLexer(RegexLexer):
"""
For `Newspeak <http://newspeaklanguage.org/>` syntax.
"""
name = 'Newspeak'
filenames = ['*.ns2']
aliases = ['newspeak', ]
mimetypes = ['text/x-newspeak']
tokens = {
'root' : [
(r'\b(Newsqueak2)\b',Keyword.Declaration),
(r"'[^']*'",String),
(r'\b(class)(\s+)([a-zA-Z0-9_]+)(\s*)',
bygroups(Keyword.Declaration,Text,Name.Class,Text)),
(r'\b(mixin|self|super|private|public|protected|nil|true|false)\b',
Keyword),
(r'([a-zA-Z0-9_]+\:)(\s*)([a-zA-Z_]\w+)',
bygroups(Name.Function,Text,Name.Variable)),
(r'([a-zA-Z0-9_]+)(\s*)(=)',
bygroups(Name.Attribute,Text,Operator)),
(r'<[a-zA-Z0-9_]+>', Comment.Special),
include('expressionstat'),
include('whitespace')
],
'expressionstat': [
(r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
(r'\d+', Number.Integer),
(r':\w+',Name.Variable),
(r'(\w+)(::)', bygroups(Name.Variable, Operator)),
(r'\w+:', Name.Function),
(r'\w+', Name.Variable),
(r'\(|\)', Punctuation),
(r'\[|\]', Punctuation),
(r'\{|\}', Punctuation),
(r'(\^|\+|\/|~|\*|<|>|=|@|%|\||&|\?|!|,|-|:)', Operator),
(r'\.|;', Punctuation),
include('whitespace'),
include('literals'),
],
'literals': [
(r'\$.', String),
(r"'[^']*'", String),
(r"#'[^']*'", String.Symbol),
(r"#\w+:?", String.Symbol),
(r"#(\+|\/|~|\*|<|>|=|@|%|\||&|\?|!|,|-)+", String.Symbol)
],
'whitespace' : [
(r'\s+', Text),
(r'"[^"]*"', Comment)
]
}
class GherkinLexer(RegexLexer):
"""
For `Gherkin <http://cukes.info/>` syntax.
*New in Pygments 1.2.*
"""
name = 'Gherkin'
aliases = ['Cucumber', 'cucumber', 'Gherkin', 'gherkin']
filenames = ['*.feature']
mimetypes = ['text/x-gherkin']
feature_keywords_regexp = ur'^(기능|機能|功能|フィーチャ|خاصية|תכונה|Функционалност|Функционал|Особина|Могућност|Özellik|Właściwość|Tính năng|Savybė|Požiadavka|Požadavek|Osobina|Ominaisuus|Omadus|OH HAI|Mogućnost|Mogucnost|Jellemző|Fīča|Funzionalità|Funktionalität|Funkcionalnost|Funkcionalitāte|Funcționalitate|Functionaliteit|Functionalitate|Funcionalidade|Fonctionnalité|Fitur|Feature|Egenskap|Egenskab|Crikey|Característica|Arwedd)(:)(.*)$'
scenario_keywords_regexp = ur'^(\s*)(시나리오 개요|시나리오|배경|背景|場景大綱|場景|场景大纲|场景|劇本大綱|劇本|テンプレ|シナリオテンプレート|シナリオテンプレ|シナリオアウトライン|シナリオ|سيناريو مخطط|سيناريو|الخلفية|תרחיש|תבנית תרחיש|רקע|Тарих|Сценарио|Сценарий структураси|Сценарий|Структура сценарија|Структура сценария|Скица|Рамка на сценарий|Пример|Предыстория|Предистория|Позадина|Основа|Концепт|Контекст|Założenia|Tình huống|Tausta|Taust|Tapausaihio|Tapaus|Szenariogrundriss|Szenario|Szablon scenariusza|Stsenaarium|Struktura scenarija|Skica|Skenario konsep|Skenario|Situācija|Senaryo taslağı|Senaryo|Scénář|Scénario|Schema dello scenario|Scenārijs pēc parauga|Scenārijs|Scenár|Scenariusz|Scenariul de şablon|Scenariul de sablon|Scenariu|Scenario Outline|Scenario Amlinellol|Scenario|Scenarijus|Scenarijaus šablonas|Scenarij|Scenarie|Rerefons|Raamstsenaarium|Primer|Pozadí|Pozadina|Pozadie|Plan du scénario|Plan du Scénario|Osnova scénáře|Osnova|Náčrt Scénáře|Náčrt Scenáru|Mate|MISHUN SRSLY|MISHUN|Kịch bản|Kontext|Konteksts|Kontekstas|Kontekst|Koncept|Khung tình huống|Khung kịch bản|Háttér|Grundlage|Geçmiş|Forgatókönyv vázlat|Forgatókönyv|Esquema do Cenário|Esquema do Cenario|Esquema del escenario|Esquema de l\'escenari|Escenario|Escenari|Dasar|Contexto|Contexte|Contesto|Condiţii|Conditii|Cenário|Cenario|Cefndir|Bối cảnh|Blokes|Bakgrunn|Bakgrund|Baggrund|Background|B4|Antecedents|Antecedentes|All y\'all|Achtergrond|Abstrakt Scenario|Abstract Scenario)(:)(.*)$'
examples_regexp = ur'^(\s*)(예|例子|例|サンプル|امثلة|דוגמאות|Сценарији|Примери|Мисоллар|Значения|Örnekler|Voorbeelden|Variantai|Tapaukset|Scenarios|Scenariji|Scenarijai|Příklady|Példák|Príklady|Przykłady|Primjeri|Primeri|Piemēri|Pavyzdžiai|Paraugs|Juhtumid|Exemplos|Exemples|Exemplele|Exempel|Examples|Esempi|Enghreifftiau|Eksempler|Ejemplos|EXAMPLZ|Dữ liệu|Contoh|Cobber|Beispiele)(:)(.*)$'
step_keywords_regexp = ur'^(\s*)(하지만|조건|만일|그리고|그러면|那麼|那么|而且|當|当|前提|假設|假如|但是|但し|並且|もし|ならば|ただし|しかし|かつ|و |متى |لكن |عندما |ثم |بفرض |اذاً |כאשר |וגם |בהינתן |אזי |אז |אבל |Унда |То |Онда |Но |Лекин |Когато |Када |Кад |К тому же |И |Задато |Задати |Задате |Если |Допустим |Дадено |Ва |Бирок |Аммо |Али |Агар |А |Și |És |anrhegedig a |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Yna |Ya know how |Ya gotta |Y |Wtedy |When y\'all |When |Wenn |WEN |Và |Ve |Und |Un |Thì |Then y\'all |Then |Tapi |Tak |Tada |Tad |Så |Soit |Siis |Si |Quando |Quand |Quan |Pryd |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Når |När |Niin |Nhưng |N |Mutta |Men |Mas |Maka |Majd |Mais |Maar |Ma |Lorsque |Lorsqu\'|Kun |Kuid |Kui |Khi |Keď |Ketika |Když |Kai |Kada |Kad |Jeżeli |Ja |Ir |I CAN HAZ |I |Ha |Givet |Given y\'all |Given |Gitt |Gegeven |Gegeben sei |Fakat |Eğer ki |Etant donné |Et |Então |Entonces |Entao |En |Eeldades |E |Duota |Donat |Donada |Diyelim ki |Dengan |De |Dato |Dar |Dann |Dan |Dado |Dacă |Daca |DEN |Când |Cuando |Cho |Cept |Cand |But y\'all |But |Biết |Bet |BUT |Atunci |And y\'all |And |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Aber |AN |A také |A )'
tokens = {
'comments': [
(r'#.*$', Comment),
],
'multiline_descriptions' : [
(step_keywords_regexp, Keyword, "#pop"),
include('comments'),
(r"(\s|.)", Name.Constant),
],
'multiline_descriptions_on_stack' : [
(step_keywords_regexp, Keyword, "#pop:2"),
include('comments'),
(r"(\s|.)", Name.Constant),
],
'scenario_table_description': [
(r"\s+\|", Text, 'scenario_table_header'),
include('comments'),
(r"(\s|.)", Name.Constant),
],
'scenario_table_header': [
(r"\s+\|\s*$", Text, "#pop:2"),
(r"(\s+\|\s*)(#.*)$", bygroups(Text, Comment), "#pop:2"),
include('comments'),
(r"\s+\|", Text),
(r"[^\|]", Name.Variable),
],
'scenario_sections_on_stack': [
(scenario_keywords_regexp,
bygroups(Text, Name.Class, Name.Class, Name.Constant),
"multiline_descriptions_on_stack"),
],
'narrative': [
include('scenario_sections_on_stack'),
(r"(\s|.)", Name.Builtin),
],
'table_vars': [
(r'(<[^>]*>)', bygroups(Name.Variable)),
],
'string': [
include('table_vars'),
(r'(\s|.)', String),
],
'py_string': [
(r'"""', String, "#pop"),
include('string'),
],
'double_string': [
(r'"', String, "#pop"),
include('string'),
],
'single_string': [
(r"'", String, "#pop"),
include('string'),
],
'root': [
(r'\n', Text),
include('comments'),
(r'"""', String, "py_string"),
(r'"', String, "double_string"),
(r"'", String, "single_string"),
include('table_vars'),
(r'@[^@\s]+', Name.Namespace),
(step_keywords_regexp, bygroups(Text, Keyword)),
(feature_keywords_regexp,
bygroups(Name.Class, Name.Class, Name.Constant), 'narrative'),
(scenario_keywords_regexp,
bygroups(Text, Name.Class, Name.Class, Name.Constant),
"multiline_descriptions"),
(examples_regexp,
bygroups(Text, Name.Class, Name.Class, Name.Constant),
"scenario_table_description"),
(r'(\s|.)', Text),
]
}
class AsymptoteLexer(RegexLexer):
"""
For `Asymptote <http://asymptote.sf.net/>`_ source code.
*New in Pygments 1.2.*
"""
name = 'Asymptote'
aliases = ['asy', 'asymptote']
filenames = ['*.asy']
mimetypes = ['text/x-asymptote']
#: optional Comment or Whitespace
_ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
tokens = {
'whitespace': [
(r'\n', Text),
(r'\s+', Text),
(r'\\\n', Text), # line continuation
(r'//(\n|(.|\n)*?[^\\]\n)', Comment),
(r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment),
],
'statements': [
# simple string (TeX friendly)
(r'"(\\\\|\\"|[^"])*"', String),
# C style string (with character escapes)
(r"'", String, 'string'),
(r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
(r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
(r'0x[0-9a-fA-F]+[Ll]?', Number.Hex),
(r'0[0-7]+[Ll]?', Number.Oct),
(r'\d+[Ll]?', Number.Integer),
(r'[~!%^&*+=|?:<>/-]', Operator),
(r'[()\[\],.]', Punctuation),
(r'\b(case)(.+?)(:)', bygroups(Keyword, using(this), Text)),
(r'(and|controls|tension|atleast|curl|if|else|while|for|do|'
r'return|break|continue|struct|typedef|new|access|import|'
r'unravel|from|include|quote|static|public|private|restricted|'
r'this|explicit|true|false|null|cycle|newframe|operator)\b', Keyword),
# Since an asy-type-name can be also an asy-function-name,
# in the following we test if the string " [a-zA-Z]" follows
# the Keyword.Type.
# Of course it is not perfect !
(r'(Braid|FitResult|Label|Legend|TreeNode|abscissa|arc|arrowhead|'
r'binarytree|binarytreeNode|block|bool|bool3|bounds|bqe|circle|'
r'conic|coord|coordsys|cputime|ellipse|file|filltype|frame|grid3|'
r'guide|horner|hsv|hyperbola|indexedTransform|int|inversion|key|'
r'light|line|linefit|marginT|marker|mass|object|pair|parabola|path|'
r'path3|pen|picture|point|position|projection|real|revolution|'
r'scaleT|scientific|segment|side|slice|splitface|string|surface|'
r'tensionSpecifier|ticklocate|ticksgridT|tickvalues|transform|'
r'transformation|tree|triangle|trilinear|triple|vector|'
r'vertex|void)(?=([ ]{1,}[a-zA-Z]))', Keyword.Type),
# Now the asy-type-name which are not asy-function-name
# except yours !
# Perhaps useless
(r'(Braid|FitResult|TreeNode|abscissa|arrowhead|block|bool|bool3|'
r'bounds|coord|frame|guide|horner|int|linefit|marginT|pair|pen|'
r'picture|position|real|revolution|slice|splitface|ticksgridT|'
r'tickvalues|tree|triple|vertex|void)\b', Keyword.Type),
('[a-zA-Z_][a-zA-Z0-9_]*:(?!:)', Name.Label),
('[a-zA-Z_][a-zA-Z0-9_]*', Name),
],
'root': [
include('whitespace'),
# functions
(r'((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))' # return arguments
r'([a-zA-Z_][a-zA-Z0-9_]*)' # method name
r'(\s*\([^;]*?\))' # signature
r'(' + _ws + r')({)',
bygroups(using(this), Name.Function, using(this), using(this),
Punctuation),
'function'),
# function declarations
(r'((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))' # return arguments
r'([a-zA-Z_][a-zA-Z0-9_]*)' # method name
r'(\s*\([^;]*?\))' # signature
r'(' + _ws + r')(;)',
bygroups(using(this), Name.Function, using(this), using(this),
Punctuation)),
('', Text, 'statement'),
],
'statement' : [
include('whitespace'),
include('statements'),
('[{}]', Punctuation),
(';', Punctuation, '#pop'),
],
'function': [
include('whitespace'),
include('statements'),
(';', Punctuation),
('{', Punctuation, '#push'),
('}', Punctuation, '#pop'),
],
'string': [
(r"'", String, '#pop'),
(r'\\([\\abfnrtv"\'?]|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
(r'\n', String),
(r"[^\\'\n]+", String), # all other characters
(r'\\\n', String),
(r'\\n', String), # line continuation
(r'\\', String), # stray backslash
]
}
def get_tokens_unprocessed(self, text):
from pygments.lexers._asybuiltins import ASYFUNCNAME, ASYVARNAME
for index, token, value in \
RegexLexer.get_tokens_unprocessed(self, text):
if token is Name and value in ASYFUNCNAME:
token = Name.Function
elif token is Name and value in ASYVARNAME:
token = Name.Variable
yield index, token, value
| 46.441598 | 1,414 | 0.499528 | [
"Apache-2.0"
] | TheDleo/backplanejs | tools/yuidoc/bin/pygments/lexers/other.py | 107,772 | Python |