text
stringlengths 4
1.02M
| meta
dict |
|---|---|
def test_hello_world(workspace):
workspace.src('pom.xml', r'''
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.mycompany.app</groupId>
<artifactId>my-app</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
''')
workspace.src('src/main/java/com/mycompany/app/App.java', r'''
package com.mycompany.app;
public class App {
public static void main(String[] args) {
System.out.print("Hello, World!");
}
}
''')
workspace.run('mvn package');
assert workspace.run('java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App').out == 'Hello, World!'
| {
"content_hash": "61a870735974070cd349a7fab78e707c",
"timestamp": "",
"source": "github",
"line_count": 37,
"max_line_length": 112,
"avg_line_length": 27.972972972972972,
"alnum_prop": 0.5990338164251208,
"repo_name": "imsardine/learning",
"id": "0ddfb41f73a8d1f812f28efc88f88a1a23ad591e",
"size": "1035",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "maven/tests/test_start.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Dockerfile",
"bytes": "5865"
},
{
"name": "HTML",
"bytes": "1033"
},
{
"name": "Java",
"bytes": "90086"
},
{
"name": "JavaScript",
"bytes": "2052"
},
{
"name": "Makefile",
"bytes": "17149"
},
{
"name": "Python",
"bytes": "328931"
},
{
"name": "Rust",
"bytes": "899"
},
{
"name": "Shell",
"bytes": "610"
},
{
"name": "Swift",
"bytes": "3004"
}
],
"symlink_target": ""
} |
"""
Ex. 7: Write a python program that creates a list. One of the elements of the list
should be a dictionary with at least two keys. Write this list out to a file
using both YAML and JSON formats. The YAML file should be in the expanded form.
Creates a list. One of the elements of the list is a dictionary with two keys. This list
is written to a YAML file and a JSON file
"""
import yaml
import json
from pprint import pprint
def output_format(my_list, my_str):
'''
Make the output format easier to read
:param my_list: a list of the items to print
:param my_str: the name of the list
:return:
'''
print "\n\n"
print "#" * 3
print "#" * 3 + my_str
print "#" * 3
pprint(my_list)
def main():
'''
Read YAML and JSON files, pretty print to standard out
:return:
'''
yaml_file = "list_output.yml"
json_file = "list_output.json"
with open(yaml_file) as f:
yaml_list=yaml.load(f)
with open(json_file) as f:
json_list=json.load(f)
output_format(yaml_list, " YAML")
output_format(json_list, " JSON")
print "\n"
if __name__ == "__main__":
main()
| {
"content_hash": "dc34c10373bf8b44e453ee35be5ba32c",
"timestamp": "",
"source": "github",
"line_count": 47,
"max_line_length": 88,
"avg_line_length": 24.595744680851062,
"alnum_prop": 0.634083044982699,
"repo_name": "jrslocum17/pynet_test",
"id": "4c0495ea9db8deac963b706997d02993225c2cb4",
"size": "1178",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "Week1/read_and_print_list.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Python",
"bytes": "73175"
}
],
"symlink_target": ""
} |
from pagediterator import PagedIterator
from unittest import TestCase
from mock import MagicMock, call
class PagedIterator1(PagedIterator):
def __init__(self):
PagedIterator.__init__(self)
self.fetch_page(0)
@property
def total_size(self):
return self._total_size
@property
def page_size(self):
return self._page_size
def fetch_page(self, page_number):
self._total_size = 8
self._page_size = 3
pages = [
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8 ],
]
return pages[page_number]
def get_page(self, page_number):
return self.fetch_page(page_number)
class PagedIteratorTest(TestCase):
def setUp(self):
self.iterator = PagedIterator1()
def test_count_returns_an_integer(self):
self.assertEqual(len(self.iterator), 8)
def test_fetching_a_negative_index_throws_an_exception(self):
self.assertRaises(IndexError, self.iterator.__getitem__, -1)
def test_fetching_an_out_of_bounds_index_throws_exception(self):
self.assertRaises(IndexError, self.iterator.__getitem__, 15)
def test_a_page_size_must_be_set(self):
self.assertEqual(self.iterator.page_size, 3)
def test_get_first_element(self):
self.assertEqual(self.iterator[0], 1)
def test_get_second_element(self):
self.assertEqual(self.iterator[1], 2)
def test_get_first_element_on_second_page(self):
self.assertEqual(self.iterator[3], 4)
def test_get_second_element_on_third_page(self):
self.assertEqual(self.iterator[7], 8)
def test_fetching_a_string_index_is_not_allowed(self):
self.assertRaises(ValueError, self.iterator.__getitem__, 'foo')
def test_offset_that_is_valid_returns_true(self):
self.assertEqual(self.iterator[0], True)
def test_offset_that_is_out_of_bounds_returns_false(self):
self.assertEqual(15 in self.iterator, False)
def test_offset_that_is_after_the_last_element_returns_false(self):
self.assertEqual(10 in self.iterator, False)
def test_values_of_the_same_index_are_cached(self):
self.iterator.get_page = MagicMock(return_value=[1])
self.assertEqual(self.iterator[0], 1)
self.assertEqual(self.iterator[0], 1)
self.iterator.get_page.assert_called_once_with(0)
def test_values_of_the_same_pages_are_cached(self):
self.iterator.get_page = MagicMock(return_value=[1, 2])
self.assertEqual(self.iterator[0], 1)
self.assertEqual(self.iterator[1], 2)
self.iterator.get_page.assert_called_once_with(0)
def test_values_from_another_page_must_be_requested(self):
self.iterator.get_page = MagicMock(side_effect=[
[1, 2, 3],
[4, 5, 6],
])
self.assertEqual(self.iterator[0], 1)
self.assertEqual(self.iterator[3], 4)
def test_values_from_multiple_pages_are_simultaneously_cached(self):
self.iterator.get_page = MagicMock(side_effect=[
[1, 2, 3],
[4, 5, 6],
])
self.assertEqual(self.iterator[0], 1)
self.assertEqual(self.iterator[3], 4)
self.assertEqual(self.iterator[0], 1)
self.assertEqual(self.iterator[3], 4)
self.iterator.get_page.assert_has_calls([call(0), call(1)])
def test_traverse_list_in_loop(self):
result = []
for item in self.iterator:
result.append(item)
self.assertEqual(result, [1, 2, 3, 4, 5, 6, 7, 8])
def test_traverse_list_in_multiple_loops(self):
result = []
for item in self.iterator:
result.append(item)
for item in self.iterator:
result.append(item)
self.assertEqual(result, [
1, 2, 3, 4, 5, 6, 7, 8,
1, 2, 3, 4, 5, 6, 7, 8
])
def test_setting_an_element_raises_an_exception(self):
self.assertRaises(RuntimeError, self.iterator.__setitem__, 0, 0)
def test_unsetting_an_element_raises_an_exception(self):
self.assertRaises(RuntimeError, self.iterator.__delitem__, 0)
| {
"content_hash": "d68812a844208873579b786a44eb12cf",
"timestamp": "",
"source": "github",
"line_count": 124,
"max_line_length": 72,
"avg_line_length": 33.29838709677419,
"alnum_prop": 0.6224267377088883,
"repo_name": "elliotchance/pagediterator-python",
"id": "b0e7c367853b25e447aa12fee34c7049c9c8e9cd",
"size": "4129",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "test_pagediterator.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "9602"
}
],
"symlink_target": ""
} |
from __future__ import division
from vistrails.core.bundles.pyimport import py_import
from vistrails.core.modules.vistrails_module import ModuleError
from ..common import get_numpy, TableObject, Table
def get_xlrd():
try:
return py_import('xlrd', {
'pip': 'xlrd',
'linux-debian': 'python-xlrd',
'linux-ubuntu': 'python-xlrd',
'linux-fedora': 'python-xlrd'},
True)
except ImportError: # pragma: no cover
return None
class ExcelTable(TableObject):
def __init__(self, sheet, header_present):
self.sheet = sheet
self.header_present = header_present
if self.header_present:
self.names = [c.value for c in self.sheet.row(0)]
else:
self.names = None
self.rows = self.sheet.nrows
if self.header_present:
self.rows -= 1
self.columns = self.sheet.ncols
self.column_cache = {}
def get_column(self, index, numeric=False):
if (index, numeric) in self.column_cache:
return self.column_cache[(index, numeric)]
numpy = get_numpy(False)
result = [c.value for c in self.sheet.col(index)]
if self.header_present:
result = result[1:]
if numeric and numpy is not None:
result = numpy.array(result, dtype=numpy.float32)
elif numeric:
result = [float(e) for e in result]
self.column_cache[(index, numeric)] = result
return result
class ExcelSpreadsheet(Table):
"""Reads a table from a Microsoft Excel file.
This module uses xlrd from the python-excel.org project to read a XLS or
XLSX file.
"""
_input_ports = [
('file', '(org.vistrails.vistrails.basic:File)'),
('sheet_name', '(org.vistrails.vistrails.basic:String)',
{'optional': True}),
('sheet_index', '(org.vistrails.vistrails.basic:Integer)',
{'optional': True}),
('header_present', '(org.vistrails.vistrails.basic:Boolean)',
{'optional': True, 'defaults': "['False']"})]
_output_ports = [
('column_count', '(org.vistrails.vistrails.basic:Integer)'),
('column_names', '(org.vistrails.vistrails.basic:String)'),
('value', Table)]
def compute(self):
xlrd = get_xlrd()
if xlrd is None: # pragma: no cover
raise ModuleError(self, "xlrd is not available")
workbook = self.get_input('file')
workbook = xlrd.open_workbook(workbook.name)
if self.has_input('sheet_index'):
sheet_index = self.get_input('sheet_index')
if self.has_input('sheet_name'):
name = self.get_input('sheet_name')
try:
index = workbook.sheet_names().index(name)
except Exception:
raise ModuleError(self, "Sheet name not found")
if self.has_input('sheet_index'):
if sheet_index != index:
raise ModuleError(self,
"Both sheet_name and sheet_index were "
"specified, and they don't agree")
elif self.has_input('sheet_index'):
index = sheet_index
else:
index = 0
sheet = workbook.sheet_by_index(index)
header_present = self.get_input('header_present')
table = ExcelTable(sheet, header_present)
self.set_output('value', table)
if table.names is not None:
self.set_output('column_names', table.names)
self.set_output('column_count', table.columns)
_modules = [ExcelSpreadsheet]
###############################################################################
import itertools
import unittest
from vistrails.tests.utils import execute, intercept_result
from ..identifiers import identifier
from ..common import ExtractColumn
@unittest.skipIf(get_xlrd() is None, "xlrd not available")
class ExcelTestCase(unittest.TestCase):
@classmethod
def setUpClass(cls):
import os
cls._test_dir = os.path.join(
os.path.dirname(__file__),
os.pardir,
'test_files')
def assertAlmostEqual_lists(self, a, b):
for i, j in itertools.izip(a, b):
self.assertAlmostEqual(i, j, places=5)
def test_xls_numeric(self):
"""Uses ExcelSpreadsheet to load a numeric array.
"""
with intercept_result(ExtractColumn, 'value') as results:
with intercept_result(ExcelSpreadsheet, 'column_count') as cols:
self.assertFalse(execute([
('read|ExcelSpreadsheet', identifier, [
('file', [('File', self._test_dir + '/xl.xls')]),
('sheet_index', [('Integer', '1')]),
('sheet_name', [('String', 'Feuil2')]),
('header_present', [('Boolean', 'False')])
]),
('ExtractColumn', identifier, [
('column_index', [('Integer', '0')]),
('numeric', [('Boolean', 'True')]),
]),
],
[
(0, 'value', 1, 'table'),
]))
self.assertEqual(cols, [1])
self.assertEqual(len(results), 1)
self.assertAlmostEqual_lists(list(results[0]), [1, 2, 2, 3, -7.6])
def test_xls_sheet_mismatch(self):
"""Uses ExcelSpreadsheet with mismatching sheets.
"""
err = execute([
('read|ExcelSpreadsheet', identifier, [
('file', [('File', self._test_dir + '/xl.xls')]),
('sheet_index', [('Integer', '0')]),
('sheet_name', [('String', 'Feuil2')]),
]),
])
self.assertEqual(list(err.keys()), [0])
self.assertEqual(
err[0].msg,
"Both sheet_name and sheet_index were specified, and they "
"don't agree")
def test_xls_sheetname_missing(self):
"""Uses ExcelSpreadsheet with a missing sheet.
"""
err = execute([
('read|ExcelSpreadsheet', identifier, [
('file', [('File', self._test_dir + '/xl.xls')]),
('sheet_name', [('String', 'Sheet12')]),
]),
])
self.assertEqual(list(err.keys()), [0])
self.assertEqual(err[0].msg, "Sheet name not found")
def test_xls_header_nonnumeric(self):
"""Uses ExcelSpreadsheet to load data.
"""
with intercept_result(ExtractColumn, 'value') as results:
with intercept_result(ExcelSpreadsheet, 'column_count') as cols:
self.assertFalse(execute([
('read|ExcelSpreadsheet', identifier, [
('file', [('File', self._test_dir + '/xl.xls')]),
('sheet_name', [('String', 'Feuil1')]),
('header_present', [('Boolean', 'True')])
]),
('ExtractColumn', identifier, [
('column_index', [('Integer', '0')]),
('column_name', [('String', 'data1')]),
('numeric', [('Boolean', 'False')]),
]),
],
[
(0, 'value', 1, 'table'),
]))
self.assertEqual(cols, [2])
self.assertEqual(len(results), 1)
self.assertEqual(list(results[0]), ['here', 'is', 'some', 'text'])
def test_xls_header_numeric(self):
"""Uses ExcelSpreadsheet to load a numeric array.
"""
with intercept_result(ExtractColumn, 'value') as results:
with intercept_result(ExcelSpreadsheet, 'column_count') as cols:
self.assertFalse(execute([
('read|ExcelSpreadsheet', identifier, [
('file', [('File', self._test_dir + '/xl.xls')]),
# Will default to first sheet
('header_present', [('Boolean', 'True')])
]),
('ExtractColumn', identifier, [
('column_name', [('String', 'data2')]),
('numeric', [('Boolean', 'True')]),
]),
],
[
(0, 'value', 1, 'table'),
]))
self.assertEqual(cols, [2])
self.assertEqual(len(results), 1)
self.assertAlmostEqual_lists(list(results[0]), [1, -2.8, 3.4, 3.3])
| {
"content_hash": "d362b6ac9d63a7f0cefa81063fb656b6",
"timestamp": "",
"source": "github",
"line_count": 233,
"max_line_length": 79,
"avg_line_length": 38.3862660944206,
"alnum_prop": 0.48669499105545616,
"repo_name": "hjanime/VisTrails",
"id": "9dcfd6c2a1a82a2f9d39de384bae0804ed3561a3",
"size": "10810",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "vistrails/packages/tabledata/read/read_excel.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "Batchfile",
"bytes": "1421"
},
{
"name": "Inno Setup",
"bytes": "19550"
},
{
"name": "Makefile",
"bytes": "768"
},
{
"name": "Mako",
"bytes": "66613"
},
{
"name": "PHP",
"bytes": "49302"
},
{
"name": "Python",
"bytes": "19803915"
},
{
"name": "R",
"bytes": "782836"
},
{
"name": "Ruby",
"bytes": "875"
},
{
"name": "Shell",
"bytes": "35024"
},
{
"name": "TeX",
"bytes": "145333"
},
{
"name": "XSLT",
"bytes": "1090"
}
],
"symlink_target": ""
} |
import tests.model_control.test_ozone_custom_models_enabled as testmod
testmod.build_model( ['BoxCox'] , ['Lag1Trend'] , ['Seasonal_DayOfMonth'] , ['SVR'] ); | {
"content_hash": "87f0736102bd8e4f8199b08d61afa15f",
"timestamp": "",
"source": "github",
"line_count": 4,
"max_line_length": 86,
"avg_line_length": 39.75,
"alnum_prop": 0.710691823899371,
"repo_name": "antoinecarme/pyaf",
"id": "90e7dc5c9c6696e98170384be44352032a9dc698",
"size": "159",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "tests/model_control/detailed/transf_BoxCox/model_control_one_enabled_BoxCox_Lag1Trend_Seasonal_DayOfMonth_SVR.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "Makefile",
"bytes": "6773299"
},
{
"name": "Procfile",
"bytes": "24"
},
{
"name": "Python",
"bytes": "54209093"
},
{
"name": "R",
"bytes": "807"
},
{
"name": "Shell",
"bytes": "3619"
}
],
"symlink_target": ""
} |
"""Commands for reading and manipulating users."""
from googlecloudsdk.calliope import base
@base.ReleaseTracks(base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA)
class Users(base.Group):
"""Read and manipulate Google Compute Engine users."""
Users.detailed_help = {
'brief': 'Read and manipulate Google Compute Engine users',
}
| {
"content_hash": "89b0941ca9b2ef8d9e8a3a865e1e1994",
"timestamp": "",
"source": "github",
"line_count": 12,
"max_line_length": 68,
"avg_line_length": 28.083333333333332,
"alnum_prop": 0.7566765578635015,
"repo_name": "KaranToor/MA450",
"id": "eed7cc43924f7c62987c13955afd53bc7751c135",
"size": "932",
"binary": false,
"copies": "7",
"ref": "refs/heads/master",
"path": "google-cloud-sdk/.install/.backup/lib/surface/compute/users/__init__.py",
"mode": "33261",
"license": "apache-2.0",
"language": [
{
"name": "Batchfile",
"bytes": "3162"
},
{
"name": "CSS",
"bytes": "1930"
},
{
"name": "HTML",
"bytes": "13381"
},
{
"name": "Java",
"bytes": "151442"
},
{
"name": "JavaScript",
"bytes": "4906"
},
{
"name": "Makefile",
"bytes": "1636"
},
{
"name": "Objective-C",
"bytes": "13335"
},
{
"name": "PHP",
"bytes": "9086"
},
{
"name": "Pascal",
"bytes": "62"
},
{
"name": "Python",
"bytes": "19710731"
},
{
"name": "Roff",
"bytes": "2069494"
},
{
"name": "Ruby",
"bytes": "690"
},
{
"name": "Shell",
"bytes": "32272"
},
{
"name": "Smarty",
"bytes": "4968"
},
{
"name": "SourcePawn",
"bytes": "616"
},
{
"name": "Swift",
"bytes": "14225"
}
],
"symlink_target": ""
} |
from __future__ import annotations
import numpy as np
from progressivis.core.module import Module, ReturnRunStep
from progressivis.core.slot import SlotDescriptor
from progressivis.core.bitmap import bitmap
from progressivis.core.utils import indices_len
from ..io import Variable
from ..stats import Min, Max
from ..utils.psdict import PsDict
from . import BaseTable, Table, TableSelectedView
from .module import TableModule
from .hist_index import HistogramIndex
# from .mod_impl import ModuleImpl
from typing import Optional, Any, cast, Iterable
# def _get_physical_table(t):
# return t if t.base is None else _get_physical_table(t.base)
class _Selection:
def __init__(self, values: Optional[bitmap] = None):
self._values = bitmap([]) if values is None else values
def update(self, values: Iterable[int]) -> None:
self._values.update(values)
def remove(self, values: Iterable[int]) -> None:
self._values = self._values - bitmap(values)
def assign(self, values: Iterable[int]) -> None:
self._values = bitmap(values)
def add(self, values: Iterable[int]) -> None:
self._values |= bitmap(values)
class RangeQueryImpl: # (ModuleImpl):
def __init__(self, column: list[str], approximate: bool):
super(RangeQueryImpl, self).__init__()
self._table: Optional[BaseTable] = None
self._column = column
# self.bins = None
# self._hist_index = hist_index
self._approximate = approximate
self.result: Optional[_Selection] = None
self.is_started = False
def resume(
self,
hist_index: HistogramIndex,
lower: float,
upper: float,
limit_changed: bool,
created: Optional[bitmap] = None,
updated: Optional[bitmap] = None,
deleted: Optional[bitmap] = None,
) -> None:
assert self.result
if limit_changed:
new_sel = hist_index.range_query(
lower, upper, approximate=self._approximate
)
self.result.assign(new_sel)
return
if updated:
self.result.remove(updated)
# res = self._eval_to_ids(limit, updated)
res = hist_index.restricted_range_query(
lower, upper, only_locs=updated, approximate=self._approximate
)
self.result.add(res)
if created:
res = hist_index.restricted_range_query(
lower, upper, only_locs=created, approximate=self._approximate
)
self.result.update(res)
if deleted:
self.result.remove(deleted)
def start(
self,
table: BaseTable,
hist_index: HistogramIndex,
lower: float,
upper: float,
limit_changed: bool,
created: Optional[bitmap] = None,
updated: Optional[bitmap] = None,
deleted: Optional[bitmap] = None,
) -> None:
self._table = table
self.result = _Selection()
self.is_started = True
self.resume(hist_index, lower, upper, limit_changed, created, updated, deleted)
class RangeQuery(TableModule):
""" """
parameters = [
("column", np.dtype(object), "unknown"),
("watched_key_lower", np.dtype(object), ""),
("watched_key_upper", np.dtype(object), ""),
# ('hist_index', object, None) # to improve ...
]
inputs = [
SlotDescriptor("table", type=Table, required=True),
SlotDescriptor("lower", type=Table, required=False),
SlotDescriptor("upper", type=Table, required=False),
SlotDescriptor("min", type=PsDict, required=False),
SlotDescriptor("max", type=PsDict, required=False),
SlotDescriptor("hist", type=Table, required=True),
]
outputs = [
SlotDescriptor("min", type=Table, required=False),
SlotDescriptor("max", type=Table, required=False),
]
def __init__(
self,
# hist_index: Optional[HistogramIndex] = None,
approximate: bool = False,
**kwds: Any
) -> None:
super(RangeQuery, self).__init__(**kwds)
self._impl: RangeQueryImpl = RangeQueryImpl(self.params.column, approximate)
# self._hist_index: Optional[HistogramIndex] = hist_index
self._approximate = approximate
self.default_step_size = 1000
self.input_module: Optional[Module] = None
self._min_table: Optional[PsDict] = None
self._max_table: Optional[PsDict] = None
self.hist_index: Optional[HistogramIndex] = None
# @property
# def hist_index(self) -> Optional[HistogramIndex]:
# return self._hist_index
# @hist_index.setter
# def hist_index(self, hi: HistogramIndex) -> None:
# self._hist_index = hi
# self._impl = RangeQueryImpl(self._column, hi, approximate=self._approximate)
@property
def column(self) -> str:
return str(self.params.column)
@property
def watched_key_lower(self) -> str:
return self.params.watched_key_lower or self.column
@property
def watched_key_upper(self) -> str:
return self.params.watched_key_upper or self.column
def create_dependent_modules(
self,
input_module: Module,
input_slot: str,
min_: Optional[Module] = None,
max_: Optional[Module] = None,
min_value: Optional[Module] = None,
max_value: Optional[Module] = None,
hist_index: Optional[HistogramIndex] = None,
**kwds: Any
) -> RangeQuery:
if self.input_module is not None: # test if already called
return self
scheduler = self.scheduler()
params = self.params
self.input_module = input_module
self.input_slot = input_slot
with scheduler:
if hist_index is None:
hist_index = HistogramIndex(
column=params.column, group=self.name, scheduler=scheduler
)
hist_index.input.table = input_module.output[input_slot]
if min_ is None:
min_ = Min(group=self.name, columns=[self.column], scheduler=scheduler)
min_.input.table = hist_index.output.min_out
if max_ is None:
max_ = Max(group=self.name, columns=[self.column], scheduler=scheduler)
max_.input.table = hist_index.output.max_out
if min_value is None:
min_value = Variable(group=self.name, scheduler=scheduler)
min_value.input.like = min_.output.result
if max_value is None:
max_value = Variable(group=self.name, scheduler=scheduler)
max_value.input.like = max_.output.result
range_query = self
range_query.hist_index = hist_index
range_query.input.hist = hist_index.output.result
range_query.input.table = input_module.output[input_slot]
if min_value:
range_query.input.lower = min_value.output.result
if max_value:
range_query.input.upper = max_value.output.result
range_query.input.min = min_.output.result
range_query.input.max = max_.output.result
self.min = min_
self.max = max_
self.min_value = min_value
self.max_value = max_value
return range_query
def _create_min_max(self) -> None:
if self._min_table is None:
self._min_table = PsDict({self.column: np.inf})
if self._max_table is None:
self._max_table = PsDict({self.column: -np.inf})
def _set_minmax_out(self, attr_: str, val: float) -> None:
d = {self.column: val}
if getattr(self, attr_) is None:
setattr(self, attr_, PsDict(d))
else:
getattr(self, attr_).update(d)
def _set_min_out(self, val: float) -> None:
return self._set_minmax_out("_min_table", val)
def _set_max_out(self, val: float) -> None:
return self._set_minmax_out("_max_table", val)
def get_data(self, name: str) -> Any:
if name == "min":
return self._min_table
if name == "max":
return self._max_table
return super(RangeQuery, self).get_data(name)
def run_step(
self, run_number: int, step_size: int, howlong: float
) -> ReturnRunStep:
input_slot = self.get_input_slot("table")
self._create_min_max()
#
# lower/upper
#
lower_slot = self.get_input_slot("lower")
# lower_slot.update(run_number)
upper_slot = self.get_input_slot("upper")
limit_changed = False
if lower_slot.deleted.any():
lower_slot.deleted.next()
if lower_slot.updated.any():
lower_slot.updated.next()
limit_changed = True
if lower_slot.created.any():
lower_slot.created.next()
limit_changed = True
if not (lower_slot is upper_slot):
# upper_slot.update(run_number)
if upper_slot.deleted.any():
upper_slot.deleted.next()
if upper_slot.updated.any():
upper_slot.updated.next()
limit_changed = True
if upper_slot.created.any():
upper_slot.created.next()
limit_changed = True
#
# min/max
#
min_slot = self.get_input_slot("min")
min_slot.clear_buffers()
# min_slot.update(run_number)
# min_slot.created.next()
# min_slot.updated.next()
# min_slot.deleted.next()
max_slot = self.get_input_slot("max")
max_slot.clear_buffers()
# max_slot.update(run_number)
# max_slot.created.next()
# max_slot.updated.next()
# max_slot.deleted.next()
if (
lower_slot.data() is None
or upper_slot.data() is None
or len(lower_slot.data()) == 0
or len(upper_slot.data()) == 0
):
return self._return_run_step(self.state_blocked, steps_run=0)
lower_value = lower_slot.data().get(self.watched_key_lower)
upper_value = upper_slot.data().get(self.watched_key_upper)
if (
lower_slot.data() is None
or upper_slot.data() is None
or min_slot.data() is None
or max_slot.data() is None
or len(min_slot.data()) == 0
or len(max_slot.data()) == 0
):
return self._return_run_step(self.state_blocked, steps_run=0)
minv = min_slot.data().get(self.watched_key_lower)
maxv = max_slot.data().get(self.watched_key_upper)
if lower_value == "*":
lower_value = minv
elif (
lower_value is None
or np.isnan(lower_value)
or lower_value < minv
or lower_value >= maxv
):
lower_value = minv
limit_changed = True
if upper_value == "*":
upper_value = maxv
elif (
upper_value is None
or np.isnan(upper_value)
or upper_value > maxv
or upper_value <= minv
or upper_value <= lower_value
):
upper_value = maxv
limit_changed = True
self._set_min_out(lower_value)
self._set_max_out(upper_value)
# input_slot.update(run_number)
if not input_slot.has_buffered() and not limit_changed:
return self._return_run_step(self.state_blocked, steps_run=0)
# ...
steps = 0
deleted: Optional[bitmap] = None
if input_slot.deleted.any():
deleted = input_slot.deleted.next(length=step_size, as_slice=False)
steps += indices_len(deleted)
created: Optional[bitmap] = None
if input_slot.created.any():
created = input_slot.created.next(length=step_size, as_slice=False)
steps += indices_len(created)
updated: Optional[bitmap] = None
if input_slot.updated.any():
updated = input_slot.updated.next(length=step_size, as_slice=False)
steps += indices_len(updated)
input_table = input_slot.data()
if self.result is None:
self.result = TableSelectedView(input_table, bitmap([]))
assert self._impl
hist_slot = self.get_input_slot("hist")
hist_slot.clear_buffers()
if not self._impl.is_started:
self._impl.start(
input_table,
cast(HistogramIndex, hist_slot.output_module),
lower_value,
upper_value,
limit_changed,
created=created,
updated=updated,
deleted=deleted,
)
else:
self._impl.resume(
cast(HistogramIndex, hist_slot.output_module),
lower_value,
upper_value,
limit_changed,
created=created,
updated=updated,
deleted=deleted,
)
assert self._impl.result
self.selected.selection = self._impl.result._values
return self._return_run_step(self.next_state(input_slot), steps)
| {
"content_hash": "691b619c7ab35fb5aabdeefaa39a7760",
"timestamp": "",
"source": "github",
"line_count": 374,
"max_line_length": 87,
"avg_line_length": 35.68181818181818,
"alnum_prop": 0.5668040464593481,
"repo_name": "jdfekete/progressivis",
"id": "23550942289a2395eaaa486953a05c9838345539",
"size": "13345",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "progressivis/table/range_query.py",
"mode": "33188",
"license": "bsd-2-clause",
"language": [
{
"name": "Batchfile",
"bytes": "51"
},
{
"name": "C++",
"bytes": "13874"
},
{
"name": "CSS",
"bytes": "20470"
},
{
"name": "Cython",
"bytes": "1747"
},
{
"name": "HTML",
"bytes": "34701"
},
{
"name": "JavaScript",
"bytes": "305156"
},
{
"name": "Jupyter Notebook",
"bytes": "277333"
},
{
"name": "Python",
"bytes": "1812925"
},
{
"name": "Shell",
"bytes": "905"
}
],
"symlink_target": ""
} |
from ioant_mysqlhelper.db import db
from ioant import utils
import sys
import logging
logger = logging.getLogger(__name__)
def main( configFile, schemaFile ):
configuration = utils.fetch_json_file_as_dict( configFile )
schema = utils.fetch_json_file_as_dict( schemaFile )
db_host = configuration['mysqlDatabase']['host']
db_user = configuration['mysqlDatabase']['user']
db_password = configuration['mysqlDatabase']['password']
db_name = configuration['mysqlDatabase']['name']
global db_helper
db_helper = db.DatabaseHelper(db_name,
schema,
db_host,
db_user,
db_password)
if db_helper.connect_to_mysql_database():
logger.info("Connected to database")
db_helper.create_database_tables()
if __name__ == "__main__":
args = sys.argv
if ( len(args) != 3 ):
print("Invalid arguments.");
print("usage: createtables.py <configfile> <schemafile>");
sys.exit( 1 );
main( args[1], args[2] )
| {
"content_hash": "ec7e52e1157dcd4ee2963a3133b8cbdd",
"timestamp": "",
"source": "github",
"line_count": 35,
"max_line_length": 66,
"avg_line_length": 31.6,
"alnum_prop": 0.581374321880651,
"repo_name": "ioants/ioant",
"id": "221818ee6fd694c324f1aab48e99b4af5e1c00d1",
"size": "1344",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "storage/collector-python/createtables.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Batchfile",
"bytes": "435"
},
{
"name": "C",
"bytes": "18467"
},
{
"name": "C++",
"bytes": "122584"
},
{
"name": "CSS",
"bytes": "20261"
},
{
"name": "HTML",
"bytes": "7881"
},
{
"name": "JavaScript",
"bytes": "426649"
},
{
"name": "Makefile",
"bytes": "78"
},
{
"name": "PHP",
"bytes": "8160"
},
{
"name": "Protocol Buffer",
"bytes": "131289"
},
{
"name": "Python",
"bytes": "99623"
},
{
"name": "Shell",
"bytes": "907"
}
],
"symlink_target": ""
} |
"""Tests for the RC4 decrypter object."""
import unittest
from dfvfs.encryption import rc4_decrypter
from tests.encryption import test_lib
class RC4DecrypterTestCase(test_lib.DecrypterTestCase):
"""Tests for the RC4 decrypter object."""
def testInitialize(self):
"""Tests the __init__ method."""
decrypter = rc4_decrypter.RC4Decrypter(key=b'test1')
self.assertIsNotNone(decrypter)
with self.assertRaises(ValueError):
rc4_decrypter.RC4Decrypter()
def testDecrypt(self):
"""Tests the Decrypt method."""
decrypter = rc4_decrypter.RC4Decrypter(key=b'test1')
decrypted_data, _ = decrypter.Decrypt(b'\xef6\xcd\x14\xfe\xf5+y')
expected_decrypted_data = b'\x01\x02\x03\x04\x05\x06\x07\x08'
self.assertEqual(decrypted_data, expected_decrypted_data)
if __name__ == '__main__':
unittest.main()
| {
"content_hash": "40bfd391bcf76221d23255f220f15a48",
"timestamp": "",
"source": "github",
"line_count": 31,
"max_line_length": 69,
"avg_line_length": 27.225806451612904,
"alnum_prop": 0.7085308056872038,
"repo_name": "joachimmetz/dfvfs",
"id": "e5f1f0c3cfb8bb7841a4a0f4b8efc665075bdd04",
"size": "890",
"binary": false,
"copies": "2",
"ref": "refs/heads/main",
"path": "tests/encryption/rc4_decrypter.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Batchfile",
"bytes": "14212"
},
{
"name": "Makefile",
"bytes": "122"
},
{
"name": "PowerShell",
"bytes": "1021"
},
{
"name": "Python",
"bytes": "2176548"
},
{
"name": "Shell",
"bytes": "19355"
}
],
"symlink_target": ""
} |
import argparse
import calendar
import json
import os
import sys
import time
import uuid
gcp_utils_dir = os.path.abspath(os.path.join(
os.path.dirname(__file__), '../../gcp/utils'))
sys.path.append(gcp_utils_dir)
import big_query_utils
_PROJECT_ID='grpc-testing'
def _upload_netperf_latency_csv_to_bigquery(dataset_id, table_id, result_file):
with open(result_file, 'r') as f:
(col1, col2, col3) = f.read().split(',')
latency50 = float(col1.strip()) * 1000
latency90 = float(col2.strip()) * 1000
latency99 = float(col3.strip()) * 1000
scenario_result = {
'scenario': {
'name': 'netperf_tcp_rr'
},
'summary': {
'latency50': latency50,
'latency90': latency90,
'latency99': latency99
}
}
bq = big_query_utils.create_big_query()
_create_results_table(bq, dataset_id, table_id)
if not _insert_result(bq, dataset_id, table_id, scenario_result, flatten=False):
print 'Error uploading result to bigquery.'
sys.exit(1)
def _upload_scenario_result_to_bigquery(dataset_id, table_id, result_file):
with open(result_file, 'r') as f:
scenario_result = json.loads(f.read())
bq = big_query_utils.create_big_query()
_create_results_table(bq, dataset_id, table_id)
if not _insert_result(bq, dataset_id, table_id, scenario_result):
print 'Error uploading result to bigquery.'
sys.exit(1)
def _insert_result(bq, dataset_id, table_id, scenario_result, flatten=True):
if flatten:
_flatten_result_inplace(scenario_result)
_populate_metadata_inplace(scenario_result)
row = big_query_utils.make_row(str(uuid.uuid4()), scenario_result)
return big_query_utils.insert_rows(bq,
_PROJECT_ID,
dataset_id,
table_id,
[row])
def _create_results_table(bq, dataset_id, table_id):
with open(os.path.dirname(__file__) + '/scenario_result_schema.json', 'r') as f:
table_schema = json.loads(f.read())
desc = 'Results of performance benchmarks.'
return big_query_utils.create_table2(bq, _PROJECT_ID, dataset_id,
table_id, table_schema, desc)
def _flatten_result_inplace(scenario_result):
"""Bigquery is not really great for handling deeply nested data
and repeated fields. To maintain values of some fields while keeping
the schema relatively simple, we artificially leave some of the fields
as JSON strings.
"""
scenario_result['scenario']['clientConfig'] = json.dumps(scenario_result['scenario']['clientConfig'])
scenario_result['scenario']['serverConfig'] = json.dumps(scenario_result['scenario']['serverConfig'])
scenario_result['latencies'] = json.dumps(scenario_result['latencies'])
for stats in scenario_result['clientStats']:
stats['latencies'] = json.dumps(stats['latencies'])
scenario_result['serverCores'] = json.dumps(scenario_result['serverCores'])
scenario_result['clientSuccess'] = json.dumps(scenario_result['clientSuccess'])
scenario_result['serverSuccess'] = json.dumps(scenario_result['serverSuccess'])
def _populate_metadata_inplace(scenario_result):
"""Populates metadata based on environment variables set by Jenkins."""
# NOTE: Grabbing the Jenkins environment variables will only work if the
# driver is running locally on the same machine where Jenkins has started
# the job. For our setup, this is currently the case, so just assume that.
build_number = os.getenv('BUILD_NUMBER')
build_url = os.getenv('BUILD_URL')
job_name = os.getenv('JOB_NAME')
git_commit = os.getenv('GIT_COMMIT')
# actual commit is the actual head of PR that is getting tested
git_actual_commit = os.getenv('ghprbActualCommit')
utc_timestamp = str(calendar.timegm(time.gmtime()))
metadata = {'created': utc_timestamp}
if build_number:
metadata['buildNumber'] = build_number
if build_url:
metadata['buildUrl'] = build_url
if job_name:
metadata['jobName'] = job_name
if git_commit:
metadata['gitCommit'] = git_commit
if git_actual_commit:
metadata['gitActualCommit'] = git_actual_commit
scenario_result['metadata'] = metadata
argp = argparse.ArgumentParser(description='Upload result to big query.')
argp.add_argument('--bq_result_table', required=True, default=None, type=str,
help='Bigquery "dataset.table" to upload results to.')
argp.add_argument('--file_to_upload', default='scenario_result.json', type=str,
help='Report file to upload.')
argp.add_argument('--file_format',
choices=['scenario_result','netperf_latency_csv'],
default='scenario_result',
help='Format of the file to upload.')
args = argp.parse_args()
dataset_id, table_id = args.bq_result_table.split('.', 2)
if args.file_format == 'netperf_latency_csv':
_upload_netperf_latency_csv_to_bigquery(dataset_id, table_id, args.file_to_upload)
else:
_upload_scenario_result_to_bigquery(dataset_id, table_id, args.file_to_upload)
print 'Successfully uploaded %s to BigQuery.\n' % args.file_to_upload
| {
"content_hash": "2167eeaf428ffb65af7112c50563b2e3",
"timestamp": "",
"source": "github",
"line_count": 140,
"max_line_length": 103,
"avg_line_length": 36.864285714285714,
"alnum_prop": 0.6688626235225732,
"repo_name": "andrewpollock/grpc",
"id": "2a99499843adccc35bf50a33a018eb717fe76c12",
"size": "6773",
"binary": false,
"copies": "13",
"ref": "refs/heads/master",
"path": "tools/run_tests/performance/bq_upload_result.py",
"mode": "33261",
"license": "bsd-3-clause",
"language": [
{
"name": "Batchfile",
"bytes": "27784"
},
{
"name": "C",
"bytes": "5899875"
},
{
"name": "C#",
"bytes": "1323346"
},
{
"name": "C++",
"bytes": "1974130"
},
{
"name": "CMake",
"bytes": "65901"
},
{
"name": "DTrace",
"bytes": "147"
},
{
"name": "JavaScript",
"bytes": "338059"
},
{
"name": "M4",
"bytes": "37400"
},
{
"name": "Makefile",
"bytes": "683411"
},
{
"name": "Objective-C",
"bytes": "289415"
},
{
"name": "PHP",
"bytes": "149989"
},
{
"name": "Protocol Buffer",
"bytes": "104798"
},
{
"name": "PureBasic",
"bytes": "147"
},
{
"name": "Python",
"bytes": "1151370"
},
{
"name": "Ruby",
"bytes": "582230"
},
{
"name": "Shell",
"bytes": "55789"
},
{
"name": "Swift",
"bytes": "5418"
}
],
"symlink_target": ""
} |
from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
unicode_literals, with_statement)
from pants.option.arg_splitter import GLOBAL_SCOPE
class OptionsError(Exception):
"""An options system-related error."""
pass
class RegistrationError(OptionsError):
"""An error at option registration time."""
def __init__(self, msg, scope, option):
super(RegistrationError, self).__init__(
'{} [option {} in {}].'.format(msg, option,
'global scope' if scope == GLOBAL_SCOPE else 'scope {}'.format(scope)))
class ParseError(OptionsError):
"""An error at flag parsing time."""
pass
# Subclasses of RegistrationError. The distinction between them is useful mainly for testing
# that the error we get is the one we expect.
# TODO: Similar thing for ParseError.
def mk_registration_error(msg):
class Anon(RegistrationError):
def __init__(self, scope, option, **msg_format_args):
super(Anon, self).__init__(msg.format(**msg_format_args), scope, option)
return Anon
BooleanOptionImplicitVal = mk_registration_error('Boolean option cannot specify an implicit value.')
BooleanOptionNameWithNo = mk_registration_error('Boolean option names cannot start with --no.')
BooleanOptionType = mk_registration_error('Boolean option cannot specify a type.')
FrozenRegistration = mk_registration_error('Cannot register an option on a scope after registering '
'on any of its inner scopes.')
ImplicitValIsNone = mk_registration_error('Implicit value cannot be None.')
InvalidAction = mk_registration_error('Invalid action {action}.')
InvalidKwarg = mk_registration_error('Invalid registration kwarg {kwarg}.')
NoOptionNames = mk_registration_error('No option names provided.')
OptionNameDash = mk_registration_error('Option name must begin with a dash.')
OptionNameDoubleDash = mk_registration_error('Long option name must begin with a double-dash.')
RecursiveSubsystemOption = mk_registration_error("Subsystem option cannot specify 'recursive'. "
"Subsystem options are always recursive.")
Shadowing = mk_registration_error('Option shadows an option in scope {outer_scope}')
| {
"content_hash": "ed1b7787563fcdcf58f54c0ff31fa46b",
"timestamp": "",
"source": "github",
"line_count": 49,
"max_line_length": 100,
"avg_line_length": 45.97959183673469,
"alnum_prop": 0.7141588992454505,
"repo_name": "dturner-tw/pants",
"id": "59c703fc674aede0941b38ffcbe4abc2bdf296a2",
"size": "2400",
"binary": false,
"copies": "3",
"ref": "refs/heads/master",
"path": "src/python/pants/option/errors.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "C++",
"bytes": "781"
},
{
"name": "CSS",
"bytes": "11538"
},
{
"name": "Cucumber",
"bytes": "919"
},
{
"name": "GAP",
"bytes": "2459"
},
{
"name": "Go",
"bytes": "1849"
},
{
"name": "HTML",
"bytes": "70358"
},
{
"name": "Java",
"bytes": "293253"
},
{
"name": "JavaScript",
"bytes": "31042"
},
{
"name": "Protocol Buffer",
"bytes": "3783"
},
{
"name": "Python",
"bytes": "4404984"
},
{
"name": "Scala",
"bytes": "85217"
},
{
"name": "Shell",
"bytes": "50774"
},
{
"name": "Thrift",
"bytes": "2919"
}
],
"symlink_target": ""
} |
import pandas as pd
df = pd.read_csv("train_ridership_one_month.csv")
df.head()
# In[64]:
# Below code removes unwanted passenger activity codes for parking
valid_codes = [1, 9, 10, 11, 12]
df = df[df.use_type != 13 ]
df = df[df.use_type != 14 ]
clean_df = df[df.use_type != 15 ]
cols = ["transit_day", "transit_time", "station_id", "use_type", "serial_number"]
clean_df = clean_df[cols]
# In[13]:
#seperates entries and exits into two tables
entry_values = [1, 9, 12]
exit_values = [10, 11]
entry_df = clean_df.loc[df['use_type'].isin(entry_values)]
entry_df.rename(columns = {'transit_time':'entry_time'}, inplace = True)
exit_df = clean_df.loc[df['use_type'].isin(exit_values)]
exit_df.rename(columns = {'transit_time':'exit_time'}, inplace = True)
entry_df.head()
# In[60]:
#creates table of entries by day and station and then exports to csv
entry_df = entry_df.drop(['entry_time','use_type'],axis=1)
station_entry = entry_df.groupby(['station_id', 'transit_day']).count()
station_entry.rename(columns = {'serial_number':'traveler_count'}, inplace = True)
station_entry.to_csv('station_entry.csv')
# In[61]:
#creates table of exits by day and station and then exports to csv
exit_df = exit_df.drop(['exit_time','use_type'],axis=1)
station_exit = exit_df.groupby(['station_id', 'transit_day']).count()
station_exit.rename(columns = {'serial_number':'traveler_count'}, inplace = True)
station_exit.to_csv('station_exit.csv')
# In[ ]:
| {
"content_hash": "fa59050353b12fb3ad0fb68c5e4695d9",
"timestamp": "",
"source": "github",
"line_count": 54,
"max_line_length": 82,
"avg_line_length": 27,
"alnum_prop": 0.6803840877914952,
"repo_name": "loren138/martaOptimize",
"id": "bf160a6c342fc58c7a9df775ccbe1e53a785c716",
"size": "1466",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "summary.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "ApacheConf",
"bytes": "553"
},
{
"name": "HTML",
"bytes": "15738"
},
{
"name": "JavaScript",
"bytes": "1132"
},
{
"name": "PHP",
"bytes": "93323"
},
{
"name": "Python",
"bytes": "4248"
},
{
"name": "Vue",
"bytes": "563"
}
],
"symlink_target": ""
} |
"""
__ParIndexed.py_____________________________________________________
Automatically generated AToM3 syntactic object (DO NOT MODIFY DIRECTLY)
Author: gehan
Modified: Sat Aug 30 18:23:40 2014
____________________________________________________________________
"""
from ASGNode import *
from ATOM3Type import *
from ATOM3String import *
from graph_ParIndexed import *
class ParIndexed(ASGNode, ATOM3Type):
def __init__(self, parent = None):
ASGNode.__init__(self)
ATOM3Type.__init__(self)
self.superTypes = ['Proc', 'MetaModelElement_T']
self.graphClass_ = graph_ParIndexed
self.isGraphObjectVisual = True
if(hasattr(self, '_setHierarchicalLink')):
self._setHierarchicalLink(False)
if(hasattr(self, '_setHierarchicalNode')):
self._setHierarchicalNode(False)
self.parent = parent
self.cardinality=ATOM3String('1', 20)
self.cardinality=ATOM3String('1', 20)
self.classtype=ATOM3String('t_', 20)
self.classtype=ATOM3String('t_', 20)
self.name=ATOM3String('s_', 20)
self.name=ATOM3String('s_', 20)
self.generatedAttributes = {'cardinality': ('ATOM3String', ),
'cardinality': ('ATOM3String', ),
'classtype': ('ATOM3String', ),
'classtype': ('ATOM3String', ),
'name': ('ATOM3String', ),
'name': ('ATOM3String', ) }
self.realOrder = ['cardinality','cardinality','classtype','classtype','name','name']
self.directEditing = [1,1,1,1,1,1]
def clone(self):
cloneObject = ParIndexed( self.parent )
for atr in self.realOrder:
cloneObject.setAttrValue(atr, self.getAttrValue(atr).clone() )
ASGNode.cloneActions(self, cloneObject)
return cloneObject
def copy(self, other):
ATOM3Type.copy(self, other)
for atr in self.realOrder:
self.setAttrValue(atr, other.getAttrValue(atr) )
ASGNode.copy(self, other)
def preCondition (self, actionID, * params):
if self.graphObject_:
return self.graphObject_.preCondition(actionID, params)
else: return None
def postCondition (self, actionID, * params):
if self.graphObject_:
return self.graphObject_.postCondition(actionID, params)
else: return None
def preAction (self, actionID, * params):
if self.graphObject_:
return self.graphObject_.preAction(actionID, params)
else: return None
def postAction (self, actionID, * params):
if self.graphObject_:
return self.graphObject_.postAction(actionID, params)
else: return None
def QOCA(self, params):
"""
QOCA Constraint Template
NOTE: DO NOT select a POST/PRE action trigger
Constraints will be added/removed in a logical manner by other mechanisms.
"""
return # <---- Remove this to use QOCA
""" Get the high level constraint helper and solver """
from Qoca.atom3constraints.OffsetConstraints import OffsetConstraints
oc = OffsetConstraints(self.parent.qocaSolver)
"""
Example constraint, see Kernel/QOCA/atom3constraints/OffsetConstraints.py
For more types of constraints
"""
oc.fixedWidth(self.graphObject_, self.graphObject_.sizeX)
oc.fixedHeight(self.graphObject_, self.graphObject_.sizeY)
| {
"content_hash": "a5d3b9dc611b5fa35e71671bd0c6d381",
"timestamp": "",
"source": "github",
"line_count": 93,
"max_line_length": 90,
"avg_line_length": 37.13978494623656,
"alnum_prop": 0.6048060220034742,
"repo_name": "levilucio/SyVOLT",
"id": "3737e03509d8d6775452f2c8c70c39a0ac181660",
"size": "3454",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "UMLRT2Kiltera_MM/ParIndexed.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Assembly",
"bytes": "166159"
},
{
"name": "Python",
"bytes": "34207588"
},
{
"name": "Shell",
"bytes": "1118"
}
],
"symlink_target": ""
} |
import sys
import pymongo
def connect(uri):
client = pymongo.MongoClient(uri)
db = client.get_default_database()
return db
def insert(db, documentName, dataArray):
document = db[documentName]
val = document.insert(dataArray)
if (val):
print("Successed!")
else:
print("Something went wrong.")
def read(db):
try:
data_column = db.data1.find()
for d in data_column:
print d
except Exception, e:
print str(e) | {
"content_hash": "1a8b9dbe589e9fd39800d8424dc07548",
"timestamp": "",
"source": "github",
"line_count": 26,
"max_line_length": 40,
"avg_line_length": 19.153846153846153,
"alnum_prop": 0.606425702811245,
"repo_name": "hasa93/DroneMap",
"id": "92503d8824548e2a3fc1208cc6828bf10afc73ba",
"size": "498",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "db_connection/db_connection.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "CSS",
"bytes": "952738"
},
{
"name": "HTML",
"bytes": "3151277"
},
{
"name": "JavaScript",
"bytes": "3996758"
},
{
"name": "PHP",
"bytes": "4192"
},
{
"name": "Python",
"bytes": "16215"
}
],
"symlink_target": ""
} |
"""Accuracy tests for ICRS transformations, primarily to/from AltAz.
"""
import numpy as np
from astropy import units as u
from astropy.tests.helper import assert_quantity_allclose as assert_allclose
from astropy.time import Time
from astropy.coordinates import (
EarthLocation, ICRS, CIRS, AltAz, HADec, SkyCoord)
from astropy.coordinates.angle_utilities import golden_spiral_grid
from astropy.coordinates import frame_transform_graph
def test_icrs_altaz_consistency():
"""
Check ICRS<->AltAz for consistency with ICRS<->CIRS<->AltAz
The latter is extensively tested in test_intermediate_transformations.py
"""
usph = golden_spiral_grid(200)
dist = np.linspace(0.5, 1, len(usph)) * u.km * 1e5
icoo = SkyCoord(ra=usph.lon, dec=usph.lat, distance=dist)
observer = EarthLocation(28*u.deg, 23*u.deg, height=2000.*u.km)
obstime = Time('J2010')
aa_frame = AltAz(obstime=obstime, location=observer)
# check we are going direct!
trans = frame_transform_graph.get_transform(ICRS, AltAz).transforms
assert(len(trans) == 1)
# check that ICRS-AltAz and ICRS->CIRS->AltAz are consistent
aa1 = icoo.transform_to(aa_frame)
aa2 = icoo.transform_to(CIRS()).transform_to(aa_frame)
assert_allclose(aa1.separation_3d(aa2), 0*u.mm, atol=1*u.mm)
# check roundtrip
roundtrip = icoo.transform_to(aa_frame).transform_to(icoo)
assert_allclose(roundtrip.separation_3d(icoo), 0*u.mm, atol=1*u.mm)
# check there and back via CIRS mish-mash
roundtrip = icoo.transform_to(aa_frame).transform_to(
CIRS()).transform_to(icoo)
assert_allclose(roundtrip.separation_3d(icoo), 0*u.mm, atol=1*u.mm)
def test_icrs_hadec_consistency():
"""
Check ICRS<->HADec for consistency with ICRS<->CIRS<->HADec
"""
usph = golden_spiral_grid(200)
dist = np.linspace(0.5, 1, len(usph)) * u.km * 1e5
icoo = SkyCoord(ra=usph.lon, dec=usph.lat, distance=dist)
observer = EarthLocation(28*u.deg, 23*u.deg, height=2000.*u.km)
obstime = Time('J2010')
hd_frame = HADec(obstime=obstime, location=observer)
# check we are going direct!
trans = frame_transform_graph.get_transform(ICRS, HADec).transforms
assert(len(trans) == 1)
# check that ICRS-HADec and ICRS->CIRS->HADec are consistent
aa1 = icoo.transform_to(hd_frame)
aa2 = icoo.transform_to(CIRS()).transform_to(hd_frame)
assert_allclose(aa1.separation_3d(aa2), 0*u.mm, atol=1*u.mm)
# check roundtrip
roundtrip = icoo.transform_to(hd_frame).transform_to(icoo)
assert_allclose(roundtrip.separation_3d(icoo), 0*u.mm, atol=1*u.mm)
# check there and back via CIRS mish-mash
roundtrip = icoo.transform_to(hd_frame).transform_to(
CIRS()).transform_to(icoo)
assert_allclose(roundtrip.separation_3d(icoo), 0*u.mm, atol=1*u.mm)
| {
"content_hash": "d33ba57a01c47f403b38be70c366211f",
"timestamp": "",
"source": "github",
"line_count": 77,
"max_line_length": 76,
"avg_line_length": 36.77922077922078,
"alnum_prop": 0.695268361581921,
"repo_name": "aleksandr-bakanov/astropy",
"id": "23150b7ca6fba39a983666ff8f89113a6eba4fa4",
"size": "2896",
"binary": false,
"copies": "3",
"ref": "refs/heads/main",
"path": "astropy/coordinates/tests/test_icrs_observed_transformations.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "C",
"bytes": "444651"
},
{
"name": "C++",
"bytes": "1057"
},
{
"name": "HTML",
"bytes": "1172"
},
{
"name": "Objective-C",
"bytes": "615"
},
{
"name": "Python",
"bytes": "9898093"
},
{
"name": "TeX",
"bytes": "853"
}
],
"symlink_target": ""
} |
"""autogenerated by genpy from aruco/marker_info.msg. Do not edit."""
import sys
python3 = True if sys.hexversion > 0x03000000 else False
import genpy
import struct
class marker_info(genpy.Message):
_md5sum = "e5991c0caab369f6cfa37dfa3bc945ad"
_type = "aruco/marker_info"
_has_header = False #flag to mark the presence of a Header object
_full_text = """int8 numberOfMarkers
int8[] id
float32[] area
float32[] perimeter
float32[] centerX
float32[] centerY
float32[] rotX
float32[] rotY
float32[] rotZ
float32[] distance
float32[] trsX
float32[] trsY
"""
__slots__ = ['numberOfMarkers','id','area','perimeter','centerX','centerY','rotX','rotY','rotZ','distance','trsX','trsY']
_slot_types = ['int8','int8[]','float32[]','float32[]','float32[]','float32[]','float32[]','float32[]','float32[]','float32[]','float32[]','float32[]']
def __init__(self, *args, **kwds):
"""
Constructor. Any message fields that are implicitly/explicitly
set to None will be assigned a default value. The recommend
use is keyword arguments as this is more robust to future message
changes. You cannot mix in-order arguments and keyword arguments.
The available fields are:
numberOfMarkers,id,area,perimeter,centerX,centerY,rotX,rotY,rotZ,distance,trsX,trsY
:param args: complete set of field values, in .msg order
:param kwds: use keyword arguments corresponding to message field names
to set specific fields.
"""
if args or kwds:
super(marker_info, self).__init__(*args, **kwds)
#message fields cannot be None, assign default values for those that are
if self.numberOfMarkers is None:
self.numberOfMarkers = 0
if self.id is None:
self.id = []
if self.area is None:
self.area = []
if self.perimeter is None:
self.perimeter = []
if self.centerX is None:
self.centerX = []
if self.centerY is None:
self.centerY = []
if self.rotX is None:
self.rotX = []
if self.rotY is None:
self.rotY = []
if self.rotZ is None:
self.rotZ = []
if self.distance is None:
self.distance = []
if self.trsX is None:
self.trsX = []
if self.trsY is None:
self.trsY = []
else:
self.numberOfMarkers = 0
self.id = []
self.area = []
self.perimeter = []
self.centerX = []
self.centerY = []
self.rotX = []
self.rotY = []
self.rotZ = []
self.distance = []
self.trsX = []
self.trsY = []
def _get_types(self):
"""
internal API method
"""
return self._slot_types
def serialize(self, buff):
"""
serialize message into buffer
:param buff: buffer, ``StringIO``
"""
try:
buff.write(_struct_b.pack(self.numberOfMarkers))
length = len(self.id)
buff.write(_struct_I.pack(length))
pattern = '<%sb'%length
buff.write(struct.pack(pattern, *self.id))
length = len(self.area)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.area))
length = len(self.perimeter)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.perimeter))
length = len(self.centerX)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.centerX))
length = len(self.centerY)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.centerY))
length = len(self.rotX)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.rotX))
length = len(self.rotY)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.rotY))
length = len(self.rotZ)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.rotZ))
length = len(self.distance)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.distance))
length = len(self.trsX)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.trsX))
length = len(self.trsY)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(struct.pack(pattern, *self.trsY))
except struct.error as se: self._check_types(se)
except TypeError as te: self._check_types(te)
def deserialize(self, str):
"""
unpack serialized message in str into this message instance
:param str: byte array of serialized message, ``str``
"""
try:
end = 0
start = end
end += 1
(self.numberOfMarkers,) = _struct_b.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sb'%length
start = end
end += struct.calcsize(pattern)
self.id = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.area = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.perimeter = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.centerX = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.centerY = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.rotX = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.rotY = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.rotZ = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.distance = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.trsX = struct.unpack(pattern, str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.trsY = struct.unpack(pattern, str[start:end])
return self
except struct.error as e:
raise genpy.DeserializationError(e) #most likely buffer underfill
def serialize_numpy(self, buff, numpy):
"""
serialize message with numpy array types into buffer
:param buff: buffer, ``StringIO``
:param numpy: numpy python module
"""
try:
buff.write(_struct_b.pack(self.numberOfMarkers))
length = len(self.id)
buff.write(_struct_I.pack(length))
pattern = '<%sb'%length
buff.write(self.id.tostring())
length = len(self.area)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.area.tostring())
length = len(self.perimeter)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.perimeter.tostring())
length = len(self.centerX)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.centerX.tostring())
length = len(self.centerY)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.centerY.tostring())
length = len(self.rotX)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.rotX.tostring())
length = len(self.rotY)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.rotY.tostring())
length = len(self.rotZ)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.rotZ.tostring())
length = len(self.distance)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.distance.tostring())
length = len(self.trsX)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.trsX.tostring())
length = len(self.trsY)
buff.write(_struct_I.pack(length))
pattern = '<%sf'%length
buff.write(self.trsY.tostring())
except struct.error as se: self._check_types(se)
except TypeError as te: self._check_types(te)
def deserialize_numpy(self, str, numpy):
"""
unpack serialized message in str into this message instance using numpy for array types
:param str: byte array of serialized message, ``str``
:param numpy: numpy python module
"""
try:
end = 0
start = end
end += 1
(self.numberOfMarkers,) = _struct_b.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sb'%length
start = end
end += struct.calcsize(pattern)
self.id = numpy.frombuffer(str[start:end], dtype=numpy.int8, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.area = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.perimeter = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.centerX = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.centerY = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.rotX = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.rotY = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.rotZ = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.distance = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.trsX = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
pattern = '<%sf'%length
start = end
end += struct.calcsize(pattern)
self.trsY = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
return self
except struct.error as e:
raise genpy.DeserializationError(e) #most likely buffer underfill
_struct_I = genpy.struct_I
_struct_b = struct.Struct("<b")
| {
"content_hash": "c0e5e9658a5d89bcc412c7368a7f18bb",
"timestamp": "",
"source": "github",
"line_count": 383,
"max_line_length": 153,
"avg_line_length": 33.55613577023499,
"alnum_prop": 0.6022408963585434,
"repo_name": "miguelolivaresmendez/ArUco_ROS-QR-code-detection",
"id": "29d7020c85fab897bfdbac97af7ef8e645239d30",
"size": "12852",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "src/aruco/msg/_marker_info.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "C",
"bytes": "2013"
},
{
"name": "C++",
"bytes": "191833"
},
{
"name": "Common Lisp",
"bytes": "27107"
},
{
"name": "Python",
"bytes": "12927"
}
],
"symlink_target": ""
} |
from swgpy.object import *
def create(kernel):
result = Tangible()
result.template = "object/tangible/mission/quest_item/shared_sindra_lintikoor_q2_needed.iff"
result.attribute_template_id = -1
result.stfName("loot_rori_n","sindra_lintikoor_q2_needed")
#### BEGIN MODIFICATIONS ####
#### END MODIFICATIONS ####
return result | {
"content_hash": "5dcf12ff75824441279f5f057df63c54",
"timestamp": "",
"source": "github",
"line_count": 13,
"max_line_length": 93,
"avg_line_length": 26.307692307692307,
"alnum_prop": 0.7105263157894737,
"repo_name": "obi-two/Rebelion",
"id": "b3ddec384c790683510548cc55199e92bef5cc38",
"size": "487",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "data/scripts/templates/object/tangible/mission/quest_item/shared_sindra_lintikoor_q2_needed.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Batchfile",
"bytes": "11818"
},
{
"name": "C",
"bytes": "7699"
},
{
"name": "C++",
"bytes": "2293610"
},
{
"name": "CMake",
"bytes": "39727"
},
{
"name": "PLSQL",
"bytes": "42065"
},
{
"name": "Python",
"bytes": "7499185"
},
{
"name": "SQLPL",
"bytes": "41864"
}
],
"symlink_target": ""
} |
import logging
import queue
import time
logger = logging.getLogger()
def process_queue(q, pool, func):
""" Process a priority queue based on time
The priority within the queue is the time at which the item can execute.
Continually poll the queue, popping an item only when the current time
is greater than the time at which the item is permitted to execute. The
queue is designed in this manner in order to deal with API rate limiting.
Parameters
----------
q : an instance of a priority queue
pool : a thread pool
func : the function to be executed by a thread in the threadpool
Returns
-------
null
"""
# import global
from fc import (QUEUE_TIMEOUT,
TEST_FLAG)
# get first item in the queue
priority, count, id_val, dt, email = q.get()
# loop through until the queue is empty for __ seconds
while True:
diff = priority - time.time()
# if we have crossed the timing threshold
if diff <= 0:
logger.info(('Submit | email: {_email} id: {_id}'
' | submit {_email} for execution')
.format(_email=email, _id=id_val))
if TEST_FLAG:
# submit to print_email - useful for testing
a = pool.submit(func, email)
else:
# submit to process_one_email
a = pool.submit(func, q, count, id_val, dt, email)
try:
priority, count, id_val, dt, \
email = q.get(timeout=QUEUE_TIMEOUT)
except queue.Empty:
break
# sliding scale for sleeping
# based on an idea from the pause package
# https://pypi.python.org/pypi/pause
if diff <= 0.1:
time.sleep(0.001)
elif diff <= 0.5:
time.sleep(0.01)
elif diff <= 1.5:
time.sleep(0.1)
else:
time.sleep(1)
| {
"content_hash": "2fea66f373d3bf387d70daaa8470b5be",
"timestamp": "",
"source": "github",
"line_count": 67,
"max_line_length": 77,
"avg_line_length": 29.70149253731343,
"alnum_prop": 0.550251256281407,
"repo_name": "curtisalexander/fc",
"id": "a4706b6c7dbd302890d095803d3e8e91de57dc64",
"size": "2009",
"binary": false,
"copies": "1",
"ref": "refs/heads/public",
"path": "fc/scheduler.py",
"mode": "33261",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "32372"
}
],
"symlink_target": ""
} |
import sys
#variables
new_input = sys.argv[1]
counter = 0
#initialize for loop
for i in new_input:
if counter % 2:
fun = int(new_input[counter]) * new_input[counter - 1]
sys.stdout.write(fun)
counter += 1
print("")
| {
"content_hash": "2eeee609377b70030d3f2d4d000a7893",
"timestamp": "",
"source": "github",
"line_count": 13,
"max_line_length": 56,
"avg_line_length": 17.153846153846153,
"alnum_prop": 0.672645739910314,
"repo_name": "Ca2Patton/PythonStuff",
"id": "f9243ae637c914b0933c220a5173d9e3a7afb4c8",
"size": "241",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "letters2.py",
"mode": "33261",
"license": "apache-2.0",
"language": [
{
"name": "Python",
"bytes": "30997"
}
],
"symlink_target": ""
} |
import os
import dj_database_url
here = lambda * x: os.path.join(os.path.abspath(os.path.dirname(__file__)), *x)
PROJECT_ROOT = here("..")
root = lambda * x: os.path.join(os.path.abspath(PROJECT_ROOT), *x)
DEBUG = False
TEMPLATE_DEBUG = DEBUG
ADMINS = (
('Kim Desrosiers', '[email protected]'),
)
MANAGERS = ADMINS
DATABASES = {
'default': dj_database_url.config()
}
# Hosts/domain names that are valid for this site; required if DEBUG is False
# See https://docs.djangoproject.com/en/1.5/ref/settings/#allowed-hosts
ALLOWED_HOSTS = []
# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# In a Windows environment this must be set to your system time zone.
TIME_ZONE = 'America/Montreal'
# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'
SITE_ID = 1
# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True
# If you set this to False, Django will not format dates, numbers and
# calendars according to the current locale.
USE_L10N = True
# If you set this to False, Django will not use timezone-aware datetimes.
USE_TZ = True
# Absolute filesystem path to the directory that will hold user-uploaded files.
# Example: "/var/www/example.com/media/"
MEDIA_ROOT = ''
# URL that handles the media served from MEDIA_ROOT. Make sure to use a
# trailing slash.
# Examples: "http://example.com/media/", "http://media.example.com/"
MEDIA_URL = ''
# Absolute path to the directory static files should be collected to.
# Don't put anything in this directory yourself; store your static files
# in apps' "static/" subdirectories and in STATICFILES_DIRS.
# Example: "/var/www/example.com/static/"
STATIC_ROOT = root("..", "static")
# URL prefix for static files.
# Example: "http://example.com/static/", "http://static.example.com/"
STATIC_URL = '/static/'
# Additional locations of static files
STATICFILES_DIRS = (
# Put strings here, like "/home/html/static" or "C:/www/django/static".
# Always use forward slashes, even on Windows.
# Don't forget to use absolute paths, not relative paths.
)
# List of finder classes that know how to find static files in
# various locations.
STATICFILES_FINDERS = (
'django.contrib.staticfiles.finders.FileSystemFinder',
'django.contrib.staticfiles.finders.AppDirectoriesFinder',
# 'django.contrib.staticfiles.finders.DefaultStorageFinder',
)
# Make this unique, and don't share it with anybody.
SECRET_KEY = 'ha^htba4__ebr7+^^jg%=+b8--i%_mdj9y*8hia*5x21is9*1$'
# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
# 'django.template.loaders.eggs.Loader',
)
MIDDLEWARE_CLASSES = (
'corsheaders.middleware.CorsMiddleware',
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
# Uncomment the next line for simple clickjacking protection:
# 'django.middleware.clickjacking.XFrameOptionsMiddleware',
)
ROOT_URLCONF = 'urls'
# Python dotted path to the WSGI application used by Django's runserver.
WSGI_APPLICATION = 'wsgi.application'
TEMPLATE_DIRS = (
root("templates"),
# Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
# Always use forward slashes, even on Windows.
# Don't forget to use absolute paths, not relative paths.
)
DJANGO_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.admin',
'django.contrib.admindocs',
)
THIRD_PARTY_APPS = (
'allauth',
'allauth.account',
'rest_framework',
'rest_framework.authtoken',
'rest_auth',
'rest_auth.registration',
'rest_framework_swagger',
'corsheaders',
)
LOCAL_APPS = (
'recipes',
'menus',
'users',
)
INSTALLED_APPS = DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS
REST_FRAMEWORK = {
# Use Django's standard `django.contrib.auth` permissions,
# or allow read-only access for unauthenticated users.
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.IsAuthenticated',
],
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.SessionAuthentication',
'rest_framework.authentication.TokenAuthentication',
)
}
CORS_ORIGIN_ALLOW_ALL = True
# A sample logging configuration. The only tangible logging
# performed by this configuration is to send an email to
# the site admins on every HTTP 500 error when DEBUG=False.
# See http://docs.djangoproject.com/en/dev/topics/logging for
# more details on how to customize your logging configuration.
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'filters': {
'require_debug_false': {
'()': 'django.utils.log.RequireDebugFalse'
}
},
'handlers': {
'mail_admins': {
'level': 'ERROR',
'filters': ['require_debug_false'],
'class': 'django.utils.log.AdminEmailHandler'
}
},
'loggers': {
'django.request': {
'handlers': ['mail_admins'],
'level': 'ERROR',
'propagate': True,
},
}
}
| {
"content_hash": "00c43c6d44d4bf71b84fb2b77b6d5e7b",
"timestamp": "",
"source": "github",
"line_count": 188,
"max_line_length": 88,
"avg_line_length": 30.69148936170213,
"alnum_prop": 0.6960138648180243,
"repo_name": "kimond/miamm",
"id": "0fc4ecf8654f437f197b0b944ac7739541447d57",
"size": "5813",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "miamm/settings/base.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "HTML",
"bytes": "2712"
},
{
"name": "Python",
"bytes": "44200"
}
],
"symlink_target": ""
} |
import base64
import hashlib
import re
import urllib2
from PyQt4 import QtCore
from urlparse import urlparse
class MessageRenderer(QtCore.QThread):
MESSAGES = {
"alert": u'<div class="alert"><span class="time">[{time}]</span> <span class="author">{user}</span>: {message}</div>',
"image": u'<span id="{url_md5}" class="upload image"><a href="{url}"><img src="data:image/{type};base64,{data}" title="{name}" {attribs} /></a></span><input type="button" onClick=\'{js}\' value="Toggle Image" />',
"image_url": u'<span id="{url_md5}" class="upload image"><a href="{url}"><img src="{url}" title="{name}" {attribs} /></a></span><input id="hide" type=button onClick=\'{js}\' value="Toggle Image" />',
"join": u'<div class="joined">--> {user} joined {room}</div>',
"leave": u'<div class="left"><-- {user} has left {room}</div>',
"message_self": u'<div class="message"><span class="time">[{time}]</span> <span class="author self">{user}</span>: {message}</div>',
"no_time_message_self": u'<div class="message"><span class="author self">{user}</span>: {message}</div>',
"message": u'<div class="message"><span class="time">[{time}]</span> <span class="author">{user}</span>: {message}</div>',
"no_time_message": u'<div class="message"><span class="author">{user}</span>: {message}</div>',
"paste": u'<div class="paste"><pre>{message}</pre></div>',
"upload": u'<span class="upload"><a href="{url}">{name}</a></span>',
"link": u'<a href="{url}">{name}</a>',
"topic": u'<div class="topic">{user} changed topic to <span class="new_topic">{topic}</span></div>',
"tweet": u'<div class="tweet"><a href="{url_user}">{user}</a> <a href="{url}">tweeted</a>: {message}</div>'
}
def __init__(self, apiToken, maximumImageWidth, room, message, live=True, updateRoom=True, showTimestamps=True, alert=False, alertIsDirectPing=False, parent=None):
super(MessageRenderer, self).__init__(parent)
self._apiToken = apiToken
self._maximumImageWidth = maximumImageWidth
self._room = room
self._message = message
self._live = live
self._updateRoom = updateRoom
self._showTimestamps = showTimestamps
self._alert = alert
self._alertIsDirectPing = alertIsDirectPing
def run(self):
html = self.render()
self.emit(QtCore.SIGNAL("render(PyQt_PyObject, PyQt_PyObject, PyQt_PyObject, PyQt_PyObject, PyQt_PyObject, PyQt_PyObject, PyQt_PyObject)"), html, self._room, self._message, self._live, self._updateRoom, self._alert, self._alertIsDirectPing)
def needsThread(self):
return self._message.is_upload() or (self._message.body and self._isInlineLink(self._message.body))
def render(self):
html = None
if self._message.is_joining():
html = self.MESSAGES["join"].format(user=self._message.user.name, room=self._room.name)
elif (self._message.is_leaving() or self._message.is_kick()):
html = self.MESSAGES["leave"].format(user=self._message.user.name, room=self._room.name)
elif self._message.is_text() or self._message.is_upload():
if self._message.body:
body = self._plainTextToHTML(self._message.tweet["tweet"] if self._message.is_tweet() else self._message.body)
if self._message.is_tweet():
body = self.MESSAGES["tweet"].format(
url_user = "http://twitter.com/{user}".format(user=self._message.tweet["user"]),
user = self._message.tweet["user"],
url = self._message.tweet["url"],
message = body
)
elif self._message.is_paste():
body = self.MESSAGES["paste"].format(message=body)
elif self._message.is_upload():
body = self._displayUpload()
elif self._isInlineLink(body):
body = self._displayInline(body)
else:
body = self._autoLink(body)
created = QtCore.QDateTime(
self._message.created_at.year,
self._message.created_at.month,
self._message.created_at.day,
self._message.created_at.hour,
self._message.created_at.minute,
self._message.created_at.second
)
created.setTimeSpec(QtCore.Qt.UTC)
createdFormat = "h:mm ap"
if created.daysTo(QtCore.QDateTime.currentDateTime()):
createdFormat = "MMM d, {createdFormat}".format(createdFormat=createdFormat)
key = "message"
if self._message.is_by_current_user():
if self._showTimestamps:
key = "message_self"
else:
key = "no_time_message_self"
elif self._alert:
key = "alert"
elif not self._showTimestamps:
key = "no_time_message"
html = self.MESSAGES[key].format(
time = created.toLocalTime().toString(createdFormat),
user = self._message.user.name,
message = body
)
elif self._message.is_topic_change():
html = self.MESSAGES["topic"].format(user=self._message.user.name, topic=self._message.body)
return unicode(html)
def _displayInline(self, message_url):
request = urllib2.Request(message_url)
try:
response = urllib2.urlopen(request)
except:
return self._renderInlineLink(message_url, message_url)
headers = response.info()
url = message_url
if response.getcode == '200':
url = response.geturl()
meta = {
'name': url,
'type': headers["Content-Type"]
}
return self._renderInline(url=url, meta=meta)
def _displayUpload(self):
request = urllib2.Request(self._message.upload['url'])
auth_header = base64.encodestring('{}:{}'.format(self._apiToken, 'X')).replace('\n', '')
request.add_header("Authorization", "Basic {}".format(auth_header))
try:
response = urllib2.urlopen(request)
except:
return self._renderInlineLink(self._message.upload['url'], self._message.upload['name'])
data = response.read()
meta = {
'name': self._message.upload['name'],
'type': self._message.upload['content_type'],
}
return self._renderInline(url=self._message.upload['url'], data=data, meta=meta)
def _renderInline(self, url=None, data=None, meta=None):
if not url and not data:
raise Exception("Missing image data")
if self._isImage(meta["type"], meta["name"]):
attribs = "style=\"max-width: {maxWidth}px;\" ".format(maxWidth=self._maximumImageWidth)
if data:
url_md5 = hashlib.md5(url).hexdigest()
return self.MESSAGES["image"].format(
type = meta["type"],
data = base64.encodestring(data),
url = url,
url_md5 = url_md5,
name = meta["name"],
js = 'if (document.getElementById("'+url_md5+'").style.visibility == "hidden") { document.getElementById("'+url_md5+'").style.visibility="visible"} else {document.getElementById("'+url_md5+'").style.visibility="hidden"}',
attribs = attribs
)
else:
url_md5 = hashlib.md5(url).hexdigest()
return self.MESSAGES["image_url"].format(
url = url,
name = meta["name"],
url_md5 = url_md5,
js = 'if (document.getElementById("'+url_md5+'").style.visibility == "hidden") { document.getElementById("'+url_md5+'").style.visibility="visible"} else {document.getElementById("'+url_md5+'").style.visibility="hidden"}',
attribs = attribs
)
return self._renderInlineLink(url, meta["name"])
def _renderInlineLink(self, url, name):
return self.MESSAGES["link"].format(url = url, name = name)
def _isImage(self, content_type, name):
if content_type.startswith("image/"):
return True
elif content_type == "application/octet-stream" and re.search(".(gif|jpg|jpeg|png)$", name, re.IGNORECASE):
return True
return False
def _plainTextToHTML(self, string):
return string.replace("<", "<").replace(">", ">").replace("\n", "<br />")
def _autoLink(self, string):
urlre = re.compile("(\(?https?://[-A-Za-z0-9+&@#/%?=~_()|!:,.;]*[-A-Za-z0-9+&@#/%=~_()|])(\">|</a>)?")
urls = urlre.findall(string)
cleanUrls = []
for url in urls:
if url[1]:
continue
currentUrl = url[0]
if currentUrl[0] == '(' and currentUrl[-1] == ')':
currentUrl = currentUrl[1:-1]
if currentUrl in cleanUrls:
continue
cleanUrls.append(currentUrl)
string = re.sub("(?<!(=\"|\">))" + re.escape(currentUrl),
"<a href=\"" + currentUrl + "\">" + currentUrl + "</a>",
string)
return string
def _isInlineLink(self, string):
try:
url = urlparse(string)
if url.scheme is not '' and url.netloc is not '':
return True
except:
pass
return False
| {
"content_hash": "d596abb51f9689c08669c69ab5ec5959",
"timestamp": "",
"source": "github",
"line_count": 218,
"max_line_length": 248,
"avg_line_length": 44.38990825688074,
"alnum_prop": 0.5489304536529916,
"repo_name": "mariano/snakefire",
"id": "6f0918d095cdb7def616ba2fd20d0b14cae4d327",
"size": "9677",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "snakefire/renderers.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "4430"
},
{
"name": "Python",
"bytes": "339434"
},
{
"name": "Shell",
"bytes": "871"
}
],
"symlink_target": ""
} |
"""Base16, Base32, Base64 (RFC 3548), Base85 and Ascii85 data encodings"""
# Modified 04-Oct-1995 by Jack Jansen to use binascii module
# Modified 30-Dec-2003 by Barry Warsaw to add full RFC 3548 support
# Modified 22-May-2007 by Guido van Rossum to use bytes everywhere
import re
import struct
import binascii
__all__ = [
# Legacy interface exports traditional RFC 1521 Base64 encodings
'encode', 'decode', 'encodebytes', 'decodebytes',
# Generalized interface for other encodings
'b64encode', 'b64decode', 'b32encode', 'b32decode',
'b16encode', 'b16decode',
# Base85 and Ascii85 encodings
'b85encode', 'b85decode', 'a85encode', 'a85decode',
# Standard Base64 encoding
'standard_b64encode', 'standard_b64decode',
# Some common Base64 alternatives. As referenced by RFC 3458, see thread
# starting at:
#
# http://zgp.org/pipermail/p2p-hackers/2001-September/000316.html
'urlsafe_b64encode', 'urlsafe_b64decode',
]
bytes_types = (bytes, bytearray) # Types acceptable as binary data
def _bytes_from_decode_data(s):
if isinstance(s, str):
try:
return s.encode('ascii')
except UnicodeEncodeError:
raise ValueError('string argument should contain only ASCII characters')
if isinstance(s, bytes_types):
return s
try:
return memoryview(s).tobytes()
except TypeError:
raise TypeError("argument should be a bytes-like object or ASCII "
"string, not %r" % s.__class__.__name__) from None
# Base64 encoding/decoding uses binascii
def b64encode(s, altchars=None):
"""Encode a byte string using Base64.
s is the byte string to encode. Optional altchars must be a byte
string of length 2 which specifies an alternative alphabet for the
'+' and '/' characters. This allows an application to
e.g. generate url or filesystem safe Base64 strings.
The encoded byte string is returned.
"""
# Strip off the trailing newline
encoded = binascii.b2a_base64(s)[:-1]
if altchars is not None:
assert len(altchars) == 2, repr(altchars)
return encoded.translate(bytes.maketrans(b'+/', altchars))
return encoded
def b64decode(s, altchars=None, validate=False):
"""Decode a Base64 encoded byte string.
s is the byte string to decode. Optional altchars must be a
string of length 2 which specifies the alternative alphabet used
instead of the '+' and '/' characters.
The decoded string is returned. A binascii.Error is raised if s is
incorrectly padded.
If validate is False (the default), non-base64-alphabet characters are
discarded prior to the padding check. If validate is True,
non-base64-alphabet characters in the input result in a binascii.Error.
"""
s = _bytes_from_decode_data(s)
if altchars is not None:
altchars = _bytes_from_decode_data(altchars)
assert len(altchars) == 2, repr(altchars)
s = s.translate(bytes.maketrans(altchars, b'+/'))
if validate and not re.match(b'^[A-Za-z0-9+/]*={0,2}$', s):
raise binascii.Error('Non-base64 digit found')
return binascii.a2b_base64(s)
def standard_b64encode(s):
"""Encode a byte string using the standard Base64 alphabet.
s is the byte string to encode. The encoded byte string is returned.
"""
return b64encode(s)
def standard_b64decode(s):
"""Decode a byte string encoded with the standard Base64 alphabet.
s is the byte string to decode. The decoded byte string is
returned. binascii.Error is raised if the input is incorrectly
padded or if there are non-alphabet characters present in the
input.
"""
return b64decode(s)
_urlsafe_encode_translation = bytes.maketrans(b'+/', b'-_')
_urlsafe_decode_translation = bytes.maketrans(b'-_', b'+/')
def urlsafe_b64encode(s):
"""Encode a byte string using a url-safe Base64 alphabet.
s is the byte string to encode. The encoded byte string is
returned. The alphabet uses '-' instead of '+' and '_' instead of
'/'.
"""
return b64encode(s).translate(_urlsafe_encode_translation)
def urlsafe_b64decode(s):
"""Decode a byte string encoded with the standard Base64 alphabet.
s is the byte string to decode. The decoded byte string is
returned. binascii.Error is raised if the input is incorrectly
padded or if there are non-alphabet characters present in the
input.
The alphabet uses '-' instead of '+' and '_' instead of '/'.
"""
s = _bytes_from_decode_data(s)
s = s.translate(_urlsafe_decode_translation)
return b64decode(s)
# Base32 encoding/decoding must be done in Python
_b32alphabet = b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
_b32tab2 = None
_b32rev = None
def b32encode(s):
"""Encode a byte string using Base32.
s is the byte string to encode. The encoded byte string is returned.
"""
global _b32tab2
# Delay the initialization of the table to not waste memory
# if the function is never called
if _b32tab2 is None:
b32tab = [bytes((i,)) for i in _b32alphabet]
_b32tab2 = [a + b for a in b32tab for b in b32tab]
b32tab = None
if not isinstance(s, bytes_types):
s = memoryview(s).tobytes()
leftover = len(s) % 5
# Pad the last quantum with zero bits if necessary
if leftover:
s = s + bytes(5 - leftover) # Don't use += !
encoded = bytearray()
from_bytes = int.from_bytes
b32tab2 = _b32tab2
for i in range(0, len(s), 5):
c = from_bytes(s[i: i + 5], 'big')
encoded += (b32tab2[c >> 30] + # bits 1 - 10
b32tab2[(c >> 20) & 0x3ff] + # bits 11 - 20
b32tab2[(c >> 10) & 0x3ff] + # bits 21 - 30
b32tab2[c & 0x3ff] # bits 31 - 40
)
# Adjust for any leftover partial quanta
if leftover == 1:
encoded[-6:] = b'======'
elif leftover == 2:
encoded[-4:] = b'===='
elif leftover == 3:
encoded[-3:] = b'==='
elif leftover == 4:
encoded[-1:] = b'='
return bytes(encoded)
def b32decode(s, casefold=False, map01=None):
"""Decode a Base32 encoded byte string.
s is the byte string to decode. Optional casefold is a flag
specifying whether a lowercase alphabet is acceptable as input.
For security purposes, the default is False.
RFC 3548 allows for optional mapping of the digit 0 (zero) to the
letter O (oh), and for optional mapping of the digit 1 (one) to
either the letter I (eye) or letter L (el). The optional argument
map01 when not None, specifies which letter the digit 1 should be
mapped to (when map01 is not None, the digit 0 is always mapped to
the letter O). For security purposes the default is None, so that
0 and 1 are not allowed in the input.
The decoded byte string is returned. binascii.Error is raised if
the input is incorrectly padded or if there are non-alphabet
characters present in the input.
"""
global _b32rev
# Delay the initialization of the table to not waste memory
# if the function is never called
if _b32rev is None:
_b32rev = {v: k for k, v in enumerate(_b32alphabet)}
s = _bytes_from_decode_data(s)
if len(s) % 8:
raise binascii.Error('Incorrect padding')
# Handle section 2.4 zero and one mapping. The flag map01 will be either
# False, or the character to map the digit 1 (one) to. It should be
# either L (el) or I (eye).
if map01 is not None:
map01 = _bytes_from_decode_data(map01)
assert len(map01) == 1, repr(map01)
s = s.translate(bytes.maketrans(b'01', b'O' + map01))
if casefold:
s = s.upper()
# Strip off pad characters from the right. We need to count the pad
# characters because this will tell us how many null bytes to remove from
# the end of the decoded string.
l = len(s)
s = s.rstrip(b'=')
padchars = l - len(s)
# Now decode the full quanta
decoded = bytearray()
b32rev = _b32rev
for i in range(0, len(s), 8):
quanta = s[i: i + 8]
acc = 0
try:
for c in quanta:
acc = (acc << 5) + b32rev[c]
except KeyError:
raise binascii.Error('Non-base32 digit found') from None
decoded += acc.to_bytes(5, 'big')
# Process the last, partial quanta
if padchars:
acc <<= 5 * padchars
last = acc.to_bytes(5, 'big')
if padchars == 1:
decoded[-5:] = last[:-1]
elif padchars == 3:
decoded[-5:] = last[:-2]
elif padchars == 4:
decoded[-5:] = last[:-3]
elif padchars == 6:
decoded[-5:] = last[:-4]
else:
raise binascii.Error('Incorrect padding')
return bytes(decoded)
# RFC 3548, Base 16 Alphabet specifies uppercase, but hexlify() returns
# lowercase. The RFC also recommends against accepting input case
# insensitively.
def b16encode(s):
"""Encode a byte string using Base16.
s is the byte string to encode. The encoded byte string is returned.
"""
return binascii.hexlify(s).upper()
def b16decode(s, casefold=False):
"""Decode a Base16 encoded byte string.
s is the byte string to decode. Optional casefold is a flag
specifying whether a lowercase alphabet is acceptable as input.
For security purposes, the default is False.
The decoded byte string is returned. binascii.Error is raised if
s were incorrectly padded or if there are non-alphabet characters
present in the string.
"""
s = _bytes_from_decode_data(s)
if casefold:
s = s.upper()
if re.search(b'[^0-9A-F]', s):
raise binascii.Error('Non-base16 digit found')
return binascii.unhexlify(s)
#
# Ascii85 encoding/decoding
#
_a85chars = None
_a85chars2 = None
_A85START = b"<~"
_A85END = b"~>"
def _85encode(b, chars, chars2, pad=False, foldnuls=False, foldspaces=False):
# Helper function for a85encode and b85encode
if not isinstance(b, bytes_types):
b = memoryview(b).tobytes()
padding = (-len(b)) % 4
if padding:
b = b + b'\0' * padding
words = struct.Struct('!%dI' % (len(b) // 4)).unpack(b)
chunks = [b'z' if foldnuls and not word else
b'y' if foldspaces and word == 0x20202020 else
(chars2[word // 614125] +
chars2[word // 85 % 7225] +
chars[word % 85])
for word in words]
if padding and not pad:
if chunks[-1] == b'z':
chunks[-1] = chars[0] * 5
chunks[-1] = chunks[-1][:-padding]
return b''.join(chunks)
def a85encode(b, *, foldspaces=False, wrapcol=0, pad=False, adobe=False):
"""Encode a byte string using Ascii85.
b is the byte string to encode. The encoded byte string is returned.
foldspaces is an optional flag that uses the special short sequence 'y'
instead of 4 consecutive spaces (ASCII 0x20) as supported by 'btoa'. This
feature is not supported by the "standard" Adobe encoding.
wrapcol controls whether the output should have newline ('\\n') characters
added to it. If this is non-zero, each output line will be at most this
many characters long.
pad controls whether the input string is padded to a multiple of 4 before
encoding. Note that the btoa implementation always pads.
adobe controls whether the encoded byte sequence is framed with <~ and ~>,
which is used by the Adobe implementation.
"""
global _a85chars, _a85chars2
# Delay the initialization of tables to not waste memory
# if the function is never called
if _a85chars is None:
_a85chars = [bytes((i,)) for i in range(33, 118)]
_a85chars2 = [(a + b) for a in _a85chars for b in _a85chars]
result = _85encode(b, _a85chars, _a85chars2, pad, True, foldspaces)
if adobe:
result = _A85START + result
if wrapcol:
wrapcol = max(2 if adobe else 1, wrapcol)
chunks = [result[i: i + wrapcol]
for i in range(0, len(result), wrapcol)]
if adobe:
if len(chunks[-1]) + 2 > wrapcol:
chunks.append(b'')
result = b'\n'.join(chunks)
if adobe:
result += _A85END
return result
def a85decode(b, *, foldspaces=False, adobe=False, ignorechars=b' \t\n\r\v'):
"""Decode an Ascii85 encoded byte string.
s is the byte string to decode.
foldspaces is a flag that specifies whether the 'y' short sequence should be
accepted as shorthand for 4 consecutive spaces (ASCII 0x20). This feature is
not supported by the "standard" Adobe encoding.
adobe controls whether the input sequence is in Adobe Ascii85 format (i.e.
is framed with <~ and ~>).
ignorechars should be a byte string containing characters to ignore from the
input. This should only contain whitespace characters, and by default
contains all whitespace characters in ASCII.
"""
b = _bytes_from_decode_data(b)
if adobe:
if not (b.startswith(_A85START) and b.endswith(_A85END)):
raise ValueError("Ascii85 encoded byte sequences must be bracketed "
"by {!r} and {!r}".format(_A85START, _A85END))
b = b[2:-2] # Strip off start/end markers
#
# We have to go through this stepwise, so as to ignore spaces and handle
# special short sequences
#
packI = struct.Struct('!I').pack
decoded = []
decoded_append = decoded.append
curr = []
curr_append = curr.append
curr_clear = curr.clear
for x in b + b'u' * 4:
if b'!'[0] <= x <= b'u'[0]:
curr_append(x)
if len(curr) == 5:
acc = 0
for x in curr:
acc = 85 * acc + (x - 33)
try:
decoded_append(packI(acc))
except struct.error:
raise ValueError('Ascii85 overflow') from None
curr_clear()
elif x == b'z'[0]:
if curr:
raise ValueError('z inside Ascii85 5-tuple')
decoded_append(b'\0\0\0\0')
elif foldspaces and x == b'y'[0]:
if curr:
raise ValueError('y inside Ascii85 5-tuple')
decoded_append(b'\x20\x20\x20\x20')
elif x in ignorechars:
# Skip whitespace
continue
else:
raise ValueError('Non-Ascii85 digit found: %c' % x)
result = b''.join(decoded)
padding = 4 - len(curr)
if padding:
# Throw away the extra padding
result = result[:-padding]
return result
# The following code is originally taken (with permission) from Mercurial
_b85alphabet = (b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
b"abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~")
_b85chars = None
_b85chars2 = None
_b85dec = None
def b85encode(b, pad=False):
"""Encode an ASCII-encoded byte array in base85 format.
If pad is true, the input is padded with "\\0" so its length is a multiple of
4 characters before encoding.
"""
global _b85chars, _b85chars2
# Delay the initialization of tables to not waste memory
# if the function is never called
if _b85chars is None:
_b85chars = [bytes((i,)) for i in _b85alphabet]
_b85chars2 = [(a + b) for a in _b85chars for b in _b85chars]
return _85encode(b, _b85chars, _b85chars2, pad)
def b85decode(b):
"""Decode base85-encoded byte array"""
global _b85dec
# Delay the initialization of tables to not waste memory
# if the function is never called
if _b85dec is None:
_b85dec = [None] * 256
for i, c in enumerate(_b85alphabet):
_b85dec[c] = i
b = _bytes_from_decode_data(b)
padding = (-len(b)) % 5
b = b + b'~' * padding
out = []
packI = struct.Struct('!I').pack
for i in range(0, len(b), 5):
chunk = b[i:i + 5]
acc = 0
try:
for c in chunk:
acc = acc * 85 + _b85dec[c]
except TypeError:
for j, c in enumerate(chunk):
if _b85dec[c] is None:
raise ValueError('bad base85 character at position %d'
% (i + j)) from None
raise
try:
out.append(packI(acc))
except struct.error:
raise ValueError('base85 overflow in hunk starting at byte %d'
% i) from None
result = b''.join(out)
if padding:
result = result[:-padding]
return result
# Legacy interface. This code could be cleaned up since I don't believe
# binascii has any line length limitations. It just doesn't seem worth it
# though. The files should be opened in binary mode.
MAXLINESIZE = 76 # Excluding the CRLF
MAXBINSIZE = (MAXLINESIZE//4)*3
def encode(input, output):
"""Encode a file; input and output are binary files."""
while True:
s = input.read(MAXBINSIZE)
if not s:
break
while len(s) < MAXBINSIZE:
ns = input.read(MAXBINSIZE-len(s))
if not ns:
break
s += ns
line = binascii.b2a_base64(s)
output.write(line)
def decode(input, output):
"""Decode a file; input and output are binary files."""
while True:
line = input.readline()
if not line:
break
s = binascii.a2b_base64(line)
output.write(s)
def _input_type_check(s):
try:
m = memoryview(s)
except TypeError as err:
msg = "expected bytes-like object, not %s" % s.__class__.__name__
raise TypeError(msg) from err
if m.format not in ('c', 'b', 'B'):
msg = ("expected single byte elements, not %r from %s" %
(m.format, s.__class__.__name__))
raise TypeError(msg)
if m.ndim != 1:
msg = ("expected 1-D data, not %d-D data from %s" %
(m.ndim, s.__class__.__name__))
raise TypeError(msg)
def encodebytes(s):
"""Encode a bytestring into a bytestring containing multiple lines
of base-64 data."""
_input_type_check(s)
pieces = []
for i in range(0, len(s), MAXBINSIZE):
chunk = s[i : i + MAXBINSIZE]
pieces.append(binascii.b2a_base64(chunk))
return b"".join(pieces)
def encodestring(s):
"""Legacy alias of encodebytes()."""
import warnings
warnings.warn("encodestring() is a deprecated alias, use encodebytes()",
DeprecationWarning, 2)
return encodebytes(s)
def decodebytes(s):
"""Decode a bytestring of base-64 data into a bytestring."""
_input_type_check(s)
return binascii.a2b_base64(s)
def decodestring(s):
"""Legacy alias of decodebytes()."""
import warnings
warnings.warn("decodestring() is a deprecated alias, use decodebytes()",
DeprecationWarning, 2)
return decodebytes(s)
# Usable as a script...
def main():
"""Small main program"""
import sys, getopt
try:
opts, args = getopt.getopt(sys.argv[1:], 'deut')
except getopt.error as msg:
sys.stdout = sys.stderr
print(msg)
print("""usage: %s [-d|-e|-u|-t] [file|-]
-d, -u: decode
-e: encode (default)
-t: encode and decode string 'Aladdin:open sesame'"""%sys.argv[0])
sys.exit(2)
func = encode
for o, a in opts:
if o == '-e': func = encode
if o == '-d': func = decode
if o == '-u': func = decode
if o == '-t': test(); return
if args and args[0] != '-':
with open(args[0], 'rb') as f:
func(f, sys.stdout.buffer)
else:
func(sys.stdin.buffer, sys.stdout.buffer)
def test():
s0 = b"Aladdin:open sesame"
print(repr(s0))
s1 = encodebytes(s0)
print(repr(s1))
s2 = decodebytes(s1)
print(repr(s2))
assert s0 == s2
if __name__ == '__main__':
main()
| {
"content_hash": "2faf62f39dda2f45ba1008e536727ddd",
"timestamp": "",
"source": "github",
"line_count": 600,
"max_line_length": 84,
"avg_line_length": 33.57333333333333,
"alnum_prop": 0.6076747418586179,
"repo_name": "Kamik423/uni_plan",
"id": "eede5e8406b1ca60fbbde30a4346465dc188e581",
"size": "20167",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "plan/plan/lib64/python3.4/base64.py",
"mode": "33261",
"license": "apache-2.0",
"language": [
{
"name": "C",
"bytes": "55214"
},
{
"name": "CSS",
"bytes": "21814"
},
{
"name": "HTML",
"bytes": "4516"
},
{
"name": "JavaScript",
"bytes": "12528"
},
{
"name": "Makefile",
"bytes": "128416"
},
{
"name": "Python",
"bytes": "11543363"
},
{
"name": "Shell",
"bytes": "3586"
}
],
"symlink_target": ""
} |
import os
import pytest
import pushbullet
from binascii import a2b_base64
API_KEY = os.environ["PUSHBULLET_API_KEY"]
def test_decryption():
pb = pushbullet.Pushbullet(API_KEY, encryption_password="hunter2")
pb._encryption_key = a2b_base64("1sW28zp7CWv5TtGjlQpDHHG4Cbr9v36fG5o4f74LsKg=")
test_data = "MSfJxxY5YdjttlfUkCaKA57qU9SuCN8+ZhYg/xieI+lDnQ=="
decrypted = pb._decrypt_data(test_data)
assert decrypted == "meow!"
| {
"content_hash": "3ef750b695e6758dd578ed1eeb5a348b",
"timestamp": "",
"source": "github",
"line_count": 16,
"max_line_length": 83,
"avg_line_length": 27.6875,
"alnum_prop": 0.7471783295711061,
"repo_name": "Saturn/pushbullet.py",
"id": "7221dcdcccef4b6acec15560657134c03682d92d",
"size": "443",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "tests/test_e2e.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "33649"
}
],
"symlink_target": ""
} |
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('mooc', '0007_lesson_order'),
]
operations = [
migrations.CreateModel(
name='Classification',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=128, unique=True)),
],
),
migrations.AddField(
model_name='course',
name='classification',
field=models.ForeignKey(default=0, on_delete=django.db.models.deletion.CASCADE, related_name='classification', to='mooc.Classification'),
preserve_default=False,
),
]
| {
"content_hash": "2eb35640abea22055d96aab92cba3c67",
"timestamp": "",
"source": "github",
"line_count": 27,
"max_line_length": 149,
"avg_line_length": 31.296296296296298,
"alnum_prop": 0.6011834319526628,
"repo_name": "Zing22/Moogle",
"id": "294cd2383665770fa7c4aa3ae3638960ddd23330",
"size": "915",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "moogle/mooc/migrations/0008_auto_20161115_1552.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "778393"
},
{
"name": "HTML",
"bytes": "17299"
},
{
"name": "JavaScript",
"bytes": "785695"
},
{
"name": "Python",
"bytes": "22978"
}
],
"symlink_target": ""
} |
__author__ = "Simone Campagna"
__all__ = [
'RubikTestInputOutput',
]
import numpy as np
from rubik.cubes import api as cb
from rubik.shape import Shape
from ...rubik_test_case import RubikTestCase, testmethod
class RubikTestStats(RubikTestCase):
METHOD_NAMES = []
def impl_stats_random_file(self, shape, dtype, buffer_size):
dtype = cb.get_dtype(dtype)
shape = Shape(shape)
file_format = 'raw'
filename_format = "stats_random_{shape}_{dtype}.{format}"
filename = filename_format.format(shape=shape, dtype=dtype, format=file_format)
dmin = 3
for d in shape:
assert d >= dmin, "d={} < {}".format(d, dmin)
cube = cb.random_cube(shape=shape, dtype=dtype)
stats_info_cube = cb.stats_info(cube)
cube.tofile(filename)
self.assertFileExistsAndHasShape(filename, shape=shape, dtype=dtype)
stats_info_oc = cb.stats_file(filename, shape=shape, dtype=dtype, file_format=file_format,
out_of_core=False)
self.assertAlmostEqualStatsInfo(stats_info_oc, stats_info_cube)
stats_info_ooc = cb.stats_file(filename, shape=shape, dtype=dtype, file_format=file_format,
out_of_core=True, progress_frequency=-1.0, buffer_size=buffer_size)
self.assertAlmostEqualStatsInfo(stats_info_ooc, stats_info_cube)
self.assertEqual(stats_info_oc.report(), stats_info_ooc.report())
def impl_stats_const_file(self, shape, dtype, buffer_size):
dtype = cb.get_dtype(dtype)
shape = Shape(shape)
file_format = 'raw'
filename_format = "stats_const_{shape}_{dtype}.{format}"
filename = filename_format.format(shape=shape, dtype=dtype, format=file_format)
dmin = 3
for d in shape:
assert d >= dmin, "d={} < {}".format(d, dmin)
cube_max_index = tuple(0 for i in shape)
cube_min_index = tuple(1 for i in shape)
cube_zero_index = tuple(2 for i in shape)
cube_value = 1.0
cube_max = 10.0
cube_min = -23.0
cube_zero = 0.0
cube_sum = cube_max + cube_min + cube_value * (shape.count() - dmin)
cube_ave = cube_sum / float(shape.count())
cube = cb.const_cube(shape=shape, dtype=dtype, value=cube_value)
cube[cube_max_index] = cube_max
cube[cube_min_index] = cube_min
cube[cube_zero_index] = cube_zero
cube_count_zero = 1
cube_count_nonzero = shape.count() - cube_count_zero
cube_count_nan = 0
cube_count_inf = 0
stats_info_cube = cb.stats_info(cube)
self.assertEqual(stats_info_cube.cube_sum, cube_sum)
self.assertEqual(stats_info_cube.cube_ave, cube_ave)
self.assertEqual(stats_info_cube.cube_max, cube_max)
self.assertEqual(stats_info_cube.cube_min, cube_min)
self.assertEqual(stats_info_cube.cube_max_index, cube_max_index)
self.assertEqual(stats_info_cube.cube_min_index, cube_min_index)
self.assertEqual(stats_info_cube.cube_count_zero, cube_count_zero)
self.assertEqual(stats_info_cube.cube_count_nonzero, cube_count_nonzero)
self.assertEqual(stats_info_cube.cube_count_nan, cube_count_nan)
self.assertEqual(stats_info_cube.cube_count_inf, cube_count_inf)
cube.tofile(filename)
self.assertFileExistsAndHasShape(filename, shape=shape, dtype=dtype)
stats_info_oc = cb.stats_file(filename, shape=shape, dtype=dtype, file_format=file_format,
out_of_core=False)
self.assertEqual(stats_info_oc, stats_info_cube)
stats_info_ooc = cb.stats_file(filename, shape=shape, dtype=dtype, file_format=file_format,
out_of_core=True, progress_frequency=-1.0, buffer_size=buffer_size)
self.assertEqual(stats_info_ooc, stats_info_cube)
def get_buffer_size(self, shape, dtype, buffer_size=None, chunks=2):
if buffer_size is None:
buffer_size = int(shape.count() * dtype().itemsize / chunks)
return buffer_size
### tests
# random
# 4x4, float32, buffer_size=(total_size // 2)
@testmethod
def stats_random_file_4x4_float32_2chunks(self):
dtype = np.float32
shape = Shape("4x4")
self.impl_stats_random_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=2))
# 4x4, float64, buffer_size=(total_size // 3)
@testmethod
def stats_random_file_4x4_float64_2chunks(self):
dtype = np.float64
shape = Shape("4x4")
self.impl_stats_random_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=3))
# 12x8x19x5, float32, buffer_size=(total_size // 2)
@testmethod
def stats_random_file_12x8x19x5_float32_2chunks(self):
dtype = np.float32
shape = Shape("12x8x19x5")
self.impl_stats_random_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=2))
# 12x8x19x5, float64, buffer_size=(total_size // 3)
@testmethod
def stats_random_file_12x8x19x5_float64_3chunks(self):
dtype = np.float64
shape = Shape("12x8x19x5")
self.impl_stats_random_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=3))
# const
# 4x4, float32, buffer_size=(total_size // 2)
@testmethod
def stats_const_file_4x4_float32_2chunks(self):
dtype = np.float32
shape = Shape("4x4")
self.impl_stats_const_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=2))
# 4x4, float64, buffer_size=(total_size // 3)
@testmethod
def stats_const_file_4x4_float64_3chunks(self):
dtype = np.float64
shape = Shape("4x4")
self.impl_stats_const_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=3))
# 12x8x19x5, float32, buffer_size=(total_size // 2)
@testmethod
def stats_const_file_12x8x19x5_float32_2chunks(self):
dtype = np.float32
shape = Shape("12x8x19x5")
self.impl_stats_const_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=2))
# 12x8x19x5, float64, buffer_size=(total_size // 3)
@testmethod
def stats_const_file_12x8x19x5_float64_3chunks(self):
dtype = np.float64
shape = Shape("12x8x19x5")
self.impl_stats_const_file(shape=shape, dtype=dtype,
buffer_size=self.get_buffer_size(shape=shape, dtype=dtype, chunks=3))
| {
"content_hash": "18d0375910433ab399bb384b7fa5945c",
"timestamp": "",
"source": "github",
"line_count": 170,
"max_line_length": 106,
"avg_line_length": 40.34117647058824,
"alnum_prop": 0.6259842519685039,
"repo_name": "simone-campagna/rubik",
"id": "4cf5adeefe6ba19c99f10388ce1e42be9476d3e0",
"size": "7465",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "testing/rubik_testing/tests/test_cubes/rubik_test_stats.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Python",
"bytes": "546787"
}
],
"symlink_target": ""
} |
"""Invertible 1x1 Convolution used in GLOW."""
import tensorflow.compat.v2 as tf
from tensorflow_probability.python.bijectors import bijector
from tensorflow_probability.python.internal import assert_util
from tensorflow_probability.python.internal import parameter_properties
from tensorflow_probability.python.internal import prefer_static as ps
from tensorflow_probability.python.internal import tensor_util
from tensorflow_probability.python.math.linalg import lu_reconstruct
from tensorflow_probability.python.math.linalg import lu_reconstruct_assertions
from tensorflow_probability.python.math.linalg import lu_solve
from tensorflow.python.util import deprecation # pylint: disable=g-direct-tensorflow-import
__all__ = [
'MatvecLU', # Deprecated
'ScaleMatvecLU',
]
class ScaleMatvecLU(bijector.AutoCompositeTensorBijector):
"""Matrix-vector multiply using LU decomposition.
This bijector is identical to the 'Convolution1x1' used in Glow
[(Kingma and Dhariwal, 2018)[1].
#### Examples
Here's an example of initialization via random weights matrix:
```python
def trainable_lu_factorization(
event_size, batch_shape=(), seed=None, dtype=tf.float32, name=None):
with tf.name_scope(name or 'trainable_lu_factorization'):
event_size = tf.convert_to_tensor(
event_size, dtype_hint=tf.int32, name='event_size')
batch_shape = tf.convert_to_tensor(
batch_shape, dtype_hint=event_size.dtype, name='batch_shape')
random_matrix = tf.random.uniform(
shape=tf.concat([batch_shape, [event_size, event_size]], axis=0),
dtype=dtype,
seed=seed)
random_orthonormal = tf.linalg.qr(random_matrix)[0]
lower_upper, permutation = tf.linalg.lu(random_orthonormal)
lower_upper = tf.Variable(
initial_value=lower_upper,
trainable=True,
name='lower_upper')
# Initialize a non-trainable variable for the permutation indices so
# that its value isn't re-sampled from run-to-run.
permutation = tf.Variable(
initial_value=permutation,
trainable=False,
name='permutation')
return lower_upper, permutation
channels = 3
conv1x1 = tfb.ScaleMatvecLU(*trainable_lu_factorization(channels),
validate_args=True)
x = tf.random.uniform(shape=[2, 28, 28, channels])
fwd = conv1x1.forward(x)
rev_fwd = conv1x1.inverse(fwd)
# ==> x
```
To initialize this variable outside of TensorFlow, one can also use SciPy,
e.g.,
```python
def lu_factorized_random_orthonormal_matrix(channels, dtype=np.float32):
random_matrix = np.random.rand(channels, channels).astype(dtype)
lower_upper = scipy.linalg.qr(random_matrix)[0]
permutation = scipy.linalg.lu(lower_upper, overwrite_a=True)[0]
permutation = np.argmax(permutation, axis=-2)
return lower_upper, permutation
```
#### References
[1]: Diederik P. Kingma, Prafulla Dhariwal. Glow: Generative Flow with
Invertible 1x1 Convolutions. _arXiv preprint arXiv:1807.03039_, 2018.
https://arxiv.org/abs/1807.03039
"""
def __init__(self,
lower_upper,
permutation,
validate_args=False,
name=None):
"""Creates the ScaleMatvecLU bijector.
Args:
lower_upper: The LU factorization as returned by `tf.linalg.lu`.
permutation: The LU factorization permutation as returned by
`tf.linalg.lu`.
validate_args: Python `bool` indicating whether arguments should be
checked for correctness.
Default value: `False`.
name: Python `str` name given to ops managed by this object.
Default value: `None` (i.e., 'ScaleMatvecLU').
Raises:
ValueError: If both/neither `channels` and `lower_upper`/`permutation` are
specified.
"""
parameters = dict(locals())
with tf.name_scope(name or 'ScaleMatvecLU') as name:
self._lower_upper = tensor_util.convert_nonref_to_tensor(
lower_upper, dtype_hint=tf.float32, name='lower_upper')
self._permutation = tensor_util.convert_nonref_to_tensor(
permutation, dtype_hint=tf.int32, name='permutation')
super(ScaleMatvecLU, self).__init__(
dtype=self._lower_upper.dtype,
is_constant_jacobian=True,
forward_min_event_ndims=1,
validate_args=validate_args,
parameters=parameters,
name=name)
@classmethod
def _parameter_properties(cls, dtype):
# pylint: disable=g-long-lambda
return dict(
lower_upper=parameter_properties.ParameterProperties(
event_ndims=2,
shape_fn=lambda sample_shape: ps.concat(
[sample_shape, sample_shape[-1:]], axis=0),
),
permutation=parameter_properties.ParameterProperties(
event_ndims=1,
default_constraining_bijector_fn=parameter_properties
.BIJECTOR_NOT_IMPLEMENTED))
# pylint: enable=g-long-lambda
@property
def lower_upper(self):
return self._lower_upper
@property
def permutation(self):
return self._permutation
def _broadcast_params(self):
lower_upper = tf.convert_to_tensor(self.lower_upper)
perm = tf.convert_to_tensor(self.permutation)
shape = ps.broadcast_shape(ps.shape(lower_upper)[:-1],
ps.shape(perm))
lower_upper = tf.broadcast_to(
lower_upper, ps.concat([shape, shape[-1:]], 0))
perm = tf.broadcast_to(perm, shape)
return lower_upper, perm
def _forward(self, x):
lu, perm = self._broadcast_params()
w = lu_reconstruct(lower_upper=lu,
perm=perm,
validate_args=self.validate_args)
return tf.linalg.matvec(w, x)
def _inverse(self, y):
lu, perm = self._broadcast_params()
return lu_solve(
lower_upper=lu,
perm=perm,
rhs=y[..., tf.newaxis],
validate_args=self.validate_args)[..., 0]
def _forward_log_det_jacobian(self, unused_x):
return tf.reduce_sum(
tf.math.log(tf.abs(tf.linalg.diag_part(self.lower_upper))),
axis=-1)
def _parameter_control_dependencies(self, is_init):
if not self.validate_args:
return []
lu, perm = None, None
assertions = []
if (is_init != tensor_util.is_ref(self.lower_upper) or
is_init != tensor_util.is_ref(self.permutation)):
lu, perm = self._broadcast_params()
assertions.extend(lu_reconstruct_assertions(
lu, perm, self.validate_args))
if is_init != tensor_util.is_ref(self.lower_upper):
lu = tf.convert_to_tensor(self.lower_upper) if lu is None else lu
assertions.append(assert_util.assert_none_equal(
tf.linalg.diag_part(lu), tf.zeros([], dtype=lu.dtype),
message='Invertible `lower_upper` must have nonzero diagonal.'))
return assertions
class MatvecLU(ScaleMatvecLU):
"""Matrix-vector multiply using LU decomposition.
This bijector is identical to the 'Convolution1x1' used in Glow
[(Kingma and Dhariwal, 2018)[1].
#### Examples
Here's an example of initialization via random weights matrix:
```python
def trainable_lu_factorization(
event_size, batch_shape=(), seed=None, dtype=tf.float32, name=None):
with tf.name_scope(name or 'trainable_lu_factorization'):
event_size = tf.convert_to_tensor(
event_size, dtype_hint=tf.int32, name='event_size')
batch_shape = tf.convert_to_tensor(
batch_shape, dtype_hint=event_size.dtype, name='batch_shape')
random_matrix = tf.random.uniform(
shape=tf.concat([batch_shape, [event_size, event_size]], axis=0),
dtype=dtype,
seed=seed)
random_orthonormal = tf.linalg.qr(random_matrix)[0]
lower_upper, permutation = tf.linalg.lu(random_orthonormal)
lower_upper = tf.Variable(
initial_value=lower_upper,
trainable=True,
name='lower_upper')
# Initialize a non-trainable variable for the permutation indices so
# that its value isn't re-sampled from run-to-run.
permutation = tf.Variable(
initial_value=permutation,
trainable=False,
name='permutation')
return lower_upper, permutation
channels = 3
conv1x1 = tfb.MatvecLU(*trainable_lu_factorization(channels),
validate_args=True)
x = tf.random.uniform(shape=[2, 28, 28, channels])
fwd = conv1x1.forward(x)
rev_fwd = conv1x1.inverse(fwd)
# ==> x
```
To initialize this variable outside of TensorFlow, one can also use SciPy,
e.g.,
```python
def lu_factorized_random_orthonormal_matrix(channels, dtype=np.float32):
random_matrix = np.random.rand(channels, channels).astype(dtype)
lower_upper = scipy.linalg.qr(random_matrix)[0]
permutation = scipy.linalg.lu(lower_upper, overwrite_a=True)[0]
permutation = np.argmax(permutation, axis=-2)
return lower_upper, permutation
```
#### References
[1]: Diederik P. Kingma, Prafulla Dhariwal. Glow: Generative Flow with
Invertible 1x1 Convolutions. _arXiv preprint arXiv:1807.03039_, 2018.
https://arxiv.org/abs/1807.03039
"""
@deprecation.deprecated(
'2020-01-01',
'`MatvecLU` has been deprecated and renamed `ScaleMatvecLU`; please use '
'that symbol instead.')
def __init__(self,
lower_upper,
permutation,
validate_args=False,
name=None):
"""Creates the MatvecLU bijector.
Args:
lower_upper: The LU factorization as returned by `tf.linalg.lu`.
permutation: The LU factorization permutation as returned by
`tf.linalg.lu`.
validate_args: Python `bool` indicating whether arguments should be
checked for correctness.
Default value: `False`.
name: Python `str` name given to ops managed by this object.
Default value: `None` (i.e., 'MatvecLU').
Raises:
ValueError: If both/neither `channels` and `lower_upper`/`permutation` are
specified.
"""
super(MatvecLU, self).__init__(
lower_upper, permutation, validate_args=False, name=name or 'MatvecLU')
| {
"content_hash": "af8b4603268eef7b5b4738e45d044354",
"timestamp": "",
"source": "github",
"line_count": 285,
"max_line_length": 92,
"avg_line_length": 35.83157894736842,
"alnum_prop": 0.6555033294163729,
"repo_name": "tensorflow/probability",
"id": "28f48d2bdff459aead1de6af4f565eeae513f4f9",
"size": "10890",
"binary": false,
"copies": "1",
"ref": "refs/heads/main",
"path": "tensorflow_probability/python/bijectors/scale_matvec_lu.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Jupyter Notebook",
"bytes": "55552121"
},
{
"name": "Python",
"bytes": "17339674"
},
{
"name": "Shell",
"bytes": "24852"
},
{
"name": "Starlark",
"bytes": "663851"
}
],
"symlink_target": ""
} |
from __future__ import print_function
try: # Python 3
import http.client as httplib
except ImportError: # Python 2
import httplib
import json
import re
import base64
import sys
import os
import os.path
settings = {}
##### Switch endian-ness #####
def hex_switchEndian(s):
""" Switches the endianness of a hex string (in pairs of hex chars) """
pairList = [s[i:i+2].encode() for i in range(0, len(s), 2)]
return b''.join(pairList[::-1]).decode()
class BitcoinRPC:
def __init__(self, host, port, username, password):
authpair = "%s:%s" % (username, password)
authpair = authpair.encode('utf-8')
self.authhdr = b"Basic " + base64.b64encode(authpair)
self.conn = httplib.HTTPConnection(host, port=port, timeout=30)
def execute(self, obj):
try:
self.conn.request('POST', '/', json.dumps(obj),
{ 'Authorization' : self.authhdr,
'Content-type' : 'application/json' })
except ConnectionRefusedError:
print('RPC connection refused. Check RPC settings and the server status.',
file=sys.stderr)
return None
resp = self.conn.getresponse()
if resp is None:
print("JSON-RPC: no response", file=sys.stderr)
return None
body = resp.read().decode('utf-8')
resp_obj = json.loads(body)
return resp_obj
@staticmethod
def build_request(idx, method, params):
obj = { 'version' : '1.1',
'method' : method,
'id' : idx }
if params is None:
obj['params'] = []
else:
obj['params'] = params
return obj
@staticmethod
def response_is_error(resp_obj):
return 'error' in resp_obj and resp_obj['error'] is not None
def get_block_hashes(settings, max_blocks_per_call=10000):
rpc = BitcoinRPC(settings['host'], settings['port'],
settings['rpcuser'], settings['rpcpassword'])
height = settings['min_height']
while height < settings['max_height']+1:
num_blocks = min(settings['max_height']+1-height, max_blocks_per_call)
batch = []
for x in range(num_blocks):
batch.append(rpc.build_request(x, 'getblockhash', [height + x]))
reply = rpc.execute(batch)
if reply is None:
print('Cannot continue. Program will halt.')
return None
for x,resp_obj in enumerate(reply):
if rpc.response_is_error(resp_obj):
print('JSON-RPC: error at height', height+x, ': ', resp_obj['error'], file=sys.stderr)
exit(1)
assert(resp_obj['id'] == x) # assume replies are in-sequence
if settings['rev_hash_bytes'] == 'true':
resp_obj['result'] = hex_switchEndian(resp_obj['result'])
print(resp_obj['result'])
height += num_blocks
def get_rpc_cookie():
# Open the cookie file
with open(os.path.join(os.path.expanduser(settings['datadir']), '.cookie'), 'r') as f:
combined = f.readline()
combined_split = combined.split(":")
settings['rpcuser'] = combined_split[0]
settings['rpcpassword'] = combined_split[1]
if __name__ == '__main__':
if len(sys.argv) != 2:
print("Usage: linearize-hashes.py CONFIG-FILE")
sys.exit(1)
f = open(sys.argv[1])
for line in f:
# skip comment lines
m = re.search('^\s*#', line)
if m:
continue
# parse key=value lines
m = re.search('^(\w+)\s*=\s*(\S.*)$', line)
if m is None:
continue
settings[m.group(1)] = m.group(2)
f.close()
if 'host' not in settings:
settings['host'] = '127.0.0.1'
if 'port' not in settings:
settings['port'] = 12705
if 'min_height' not in settings:
settings['min_height'] = 0
if 'max_height' not in settings:
settings['max_height'] = 313000
if 'rev_hash_bytes' not in settings:
settings['rev_hash_bytes'] = 'false'
use_userpass = True
use_datadir = False
if 'rpcuser' not in settings or 'rpcpassword' not in settings:
use_userpass = False
if 'datadir' in settings and not use_userpass:
use_datadir = True
if not use_userpass and not use_datadir:
print("Missing datadir or username and/or password in cfg file", file=stderr)
sys.exit(1)
settings['port'] = int(settings['port'])
settings['min_height'] = int(settings['min_height'])
settings['max_height'] = int(settings['max_height'])
# Force hash byte format setting to be lowercase to make comparisons easier.
settings['rev_hash_bytes'] = settings['rev_hash_bytes'].lower()
# Get the rpc user and pass from the cookie if the datadir is set
if use_datadir:
get_rpc_cookie()
get_block_hashes(settings)
| {
"content_hash": "9a8a7fa25e39d654da8142f1ee57007e",
"timestamp": "",
"source": "github",
"line_count": 148,
"max_line_length": 90,
"avg_line_length": 28.91891891891892,
"alnum_prop": 0.666588785046729,
"repo_name": "ionomy/ion",
"id": "14c6524140edc438ad1601ca08aed2c33a900730",
"size": "4630",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "contrib/linearize/linearize-hashes.py",
"mode": "33261",
"license": "mit",
"language": [
{
"name": "Assembly",
"bytes": "28453"
},
{
"name": "C",
"bytes": "1392620"
},
{
"name": "C++",
"bytes": "6603677"
},
{
"name": "CMake",
"bytes": "41658"
},
{
"name": "CSS",
"bytes": "44782"
},
{
"name": "HTML",
"bytes": "21860"
},
{
"name": "Java",
"bytes": "30291"
},
{
"name": "M4",
"bytes": "201267"
},
{
"name": "Makefile",
"bytes": "119240"
},
{
"name": "Objective-C",
"bytes": "13448"
},
{
"name": "Objective-C++",
"bytes": "6627"
},
{
"name": "Python",
"bytes": "1137651"
},
{
"name": "QMake",
"bytes": "26274"
},
{
"name": "Shell",
"bytes": "73927"
}
],
"symlink_target": ""
} |
import re
import requests
from bs4 import BeautifulSoup
from metro.parser.base import BaseRuDataProvider
class DataProvider(BaseRuDataProvider):
metro_data_src = "http://ru.wikipedia.org/wiki/\
Список_станций_Киевского_метрополитена"
def download_all(self):
self.parse_usual_big_table()
| {
"content_hash": "0b228197210709b09b16a93019d8cd76",
"timestamp": "",
"source": "github",
"line_count": 13,
"max_line_length": 62,
"avg_line_length": 25.384615384615383,
"alnum_prop": 0.7121212121212122,
"repo_name": "xfenix/django-metro",
"id": "6e9556c73586ebcd994983242e80f2c48181a987",
"size": "389",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "metro/parser/providers/kiev.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "27822"
}
],
"symlink_target": ""
} |
"""FDTD cell phantom with tilted axis of rotation
The *in silico* data set was created with the
:abbr:`FDTD (Finite Difference Time Domain)` software `meep`_. The data
are 2D projections of a 3D refractive index phantom that is rotated
about an axis which is tilted by 0.2 rad (11.5 degrees) with respect
to the imaging plane. The example showcases the method
:func:`odtbrain.backpropagate_3d_tilted` which takes into account
such a tilted axis of rotation. The data are downsampled by a factor
of two. A total of 220 projections are used for the reconstruction.
Note that the information required for reconstruction decreases as the
tilt angle increases. If the tilt angle is 90 degrees w.r.t. the
imaging plane, then we get a rotating image of a cell (not images of a
rotating cell) and tomographic reconstruction is impossible. A brief
description of this algorithm is given in :cite:`Mueller2015tilted`.
The first column shows the measured phase, visualizing the
tilt (compare to other examples). The second column shows a
reconstruction that does not take into account the tilted axis of
rotation; the result is a blurry reconstruction. The third column
shows the improved reconstruction; the known tilted axis of rotation
is used in the reconstruction process.
.. _`meep`: http://ab-initio.mit.edu/wiki/index.php/Meep
"""
import matplotlib.pylab as plt
import numpy as np
import odtbrain as odt
from example_helper import load_data
sino, angles, phantom, cfg = \
load_data("fdtd_3d_sino_A220_R6.500_tiltyz0.2.tar.lzma")
A = angles.shape[0]
print("Example: Backpropagation from 3D FDTD simulations")
print("Refractive index of medium:", cfg["nm"])
print("Measurement position from object center:", cfg["lD"])
print("Wavelength sampling:", cfg["res"])
print("Axis tilt in y-z direction:", cfg["tilt_yz"])
print("Number of projections:", A)
print("Performing normal backpropagation.")
# Apply the Rytov approximation
sinoRytov = odt.sinogram_as_rytov(sino)
# Perform naive backpropagation
f_naiv = odt.backpropagate_3d(uSin=sinoRytov,
angles=angles,
res=cfg["res"],
nm=cfg["nm"],
lD=cfg["lD"]
)
print("Performing tilted backpropagation.")
# Determine tilted axis
tilted_axis = [0, np.cos(cfg["tilt_yz"]), np.sin(cfg["tilt_yz"])]
# Perform tilted backpropagation
f_tilt = odt.backpropagate_3d_tilted(uSin=sinoRytov,
angles=angles,
res=cfg["res"],
nm=cfg["nm"],
lD=cfg["lD"],
tilted_axis=tilted_axis,
)
# compute refractive index n from object function
n_naiv = odt.odt_to_ri(f_naiv, res=cfg["res"], nm=cfg["nm"])
n_tilt = odt.odt_to_ri(f_tilt, res=cfg["res"], nm=cfg["nm"])
sx, sy, sz = n_tilt.shape
px, py, pz = phantom.shape
sino_phase = np.angle(sino)
# compare phantom and reconstruction in plot
fig, axes = plt.subplots(2, 3, figsize=(8, 4.5))
kwri = {"vmin": n_tilt.real.min(), "vmax": n_tilt.real.max()}
kwph = {"vmin": sino_phase.min(), "vmax": sino_phase.max(),
"cmap": "coolwarm"}
# Sinogram
axes[0, 0].set_title("phase projection")
phmap = axes[0, 0].imshow(sino_phase[A // 2, :, :], **kwph)
axes[0, 0].set_xlabel("detector x")
axes[0, 0].set_ylabel("detector y")
axes[1, 0].set_title("sinogram slice")
axes[1, 0].imshow(sino_phase[:, :, sino.shape[2] // 2],
aspect=sino.shape[1] / sino.shape[0], **kwph)
axes[1, 0].set_xlabel("detector y")
axes[1, 0].set_ylabel("angle [rad]")
# set y ticks for sinogram
labels = np.linspace(0, 2 * np.pi, len(axes[1, 1].get_yticks()))
labels = ["{:.2f}".format(i) for i in labels]
axes[1, 0].set_yticks(np.linspace(0, len(angles), len(labels)))
axes[1, 0].set_yticklabels(labels)
axes[0, 1].set_title("normal (center)")
rimap = axes[0, 1].imshow(n_naiv[sx // 2].real, **kwri)
axes[0, 1].set_xlabel("x")
axes[0, 1].set_ylabel("y")
axes[1, 1].set_title("normal (nucleolus)")
axes[1, 1].imshow(n_naiv[int(sx / 2 + 2 * cfg["res"])].real, **kwri)
axes[1, 1].set_xlabel("x")
axes[1, 1].set_ylabel("y")
axes[0, 2].set_title("tilt correction (center)")
axes[0, 2].imshow(n_tilt[sx // 2].real, **kwri)
axes[0, 2].set_xlabel("x")
axes[0, 2].set_ylabel("y")
axes[1, 2].set_title("tilt correction (nucleolus)")
axes[1, 2].imshow(n_tilt[int(sx / 2 + 2 * cfg["res"])].real, **kwri)
axes[1, 2].set_xlabel("x")
axes[1, 2].set_ylabel("y")
# color bars
cbkwargs = {"fraction": 0.045,
"format": "%.3f"}
plt.colorbar(phmap, ax=axes[0, 0], **cbkwargs)
plt.colorbar(phmap, ax=axes[1, 0], **cbkwargs)
plt.colorbar(rimap, ax=axes[0, 1], **cbkwargs)
plt.colorbar(rimap, ax=axes[1, 1], **cbkwargs)
plt.colorbar(rimap, ax=axes[0, 2], **cbkwargs)
plt.colorbar(rimap, ax=axes[1, 2], **cbkwargs)
plt.tight_layout()
plt.show()
| {
"content_hash": "ee4b4927fbcaf9187b92196dea23b455",
"timestamp": "",
"source": "github",
"line_count": 134,
"max_line_length": 71,
"avg_line_length": 37.1865671641791,
"alnum_prop": 0.6449929761188039,
"repo_name": "paulmueller/ODTbrain",
"id": "c5238e9ab45131c890005bb4bfc93793b03d11be",
"size": "4983",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "examples/backprop_from_fdtd_3d_tilted.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "Python",
"bytes": "150751"
}
],
"symlink_target": ""
} |
import os
from oslo_privsep import capabilities as c
from oslo_privsep import priv_context
capabilities = [c.CAP_SYS_ADMIN]
# On virtual environments libraries are not owned by the Daemon user (root), so
# the Daemon needs the capability to bypass file read permission checks in
# order to dynamically load the code to run.
if os.environ.get('VIRTUAL_ENV'):
capabilities.append(c.CAP_DAC_READ_SEARCH)
# It is expected that most (if not all) os-brick operations can be
# executed with these privileges.
default = priv_context.PrivContext(
__name__,
cfg_section='privsep_osbrick',
pypath=__name__ + '.default',
capabilities=capabilities,
)
| {
"content_hash": "3f21be46a810e5e38dce1e873c5d94da",
"timestamp": "",
"source": "github",
"line_count": 22,
"max_line_length": 79,
"avg_line_length": 30.136363636363637,
"alnum_prop": 0.7405731523378583,
"repo_name": "openstack/os-brick",
"id": "c41ff533c2a4b16d28ca70710a1fbe94fdbe60d6",
"size": "1236",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "os_brick/privileged/__init__.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Python",
"bytes": "1136394"
},
{
"name": "Shell",
"bytes": "3226"
}
],
"symlink_target": ""
} |
from cliff import show
from gnocchiclient import utils
class CliCapabilitiesList(show.ShowOne):
"""List capabilities."""
def take_action(self, parsed_args):
caps = utils.get_client(self).capabilities.list()
return self.dict2columns(caps)
| {
"content_hash": "d87eeab8145711af5a0b2c55dde38f8c",
"timestamp": "",
"source": "github",
"line_count": 11,
"max_line_length": 57,
"avg_line_length": 24.181818181818183,
"alnum_prop": 0.7105263157894737,
"repo_name": "gnocchixyz/python-gnocchiclient",
"id": "bc22dd9b89113f40de4b60b82fe712a4adbe1177",
"size": "841",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "gnocchiclient/v1/capabilities_cli.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Python",
"bytes": "196841"
},
{
"name": "Shell",
"bytes": "645"
}
],
"symlink_target": ""
} |
def parse_args():
""" Parsing commandline arguments. """
from argparse import ArgumentParser
parser = ArgumentParser("./cluster.py")
parser.add_argument("input", help="input file")
parser.add_argument("output",
nargs="?",
help="output file",
default="out.txt")
parser.add_argument("labels", type=int, help="number of labels")
parser.add_argument("iterations",
type=int,
help="number of iterations")
parser.add_argument("alpha",
type=float,
help="transition hyperparameter")
parser.add_argument("beta", type=float, help="emission hyperparameter")
return parser.parse_args()
def change_count(matrix, x, y, i):
""" Change the count in a matrix.
Arguments:
matrix - transition or emission matrix
x - emission or label
y - label
i - change in count
"""
matrix["%s|%s" % (x, y)] += i
matrix["%s" % y] += i
def get_value(matrix, *args):
""" Returns the value to a key.
Arguments:
*args arbitrary number of arguments
"""
if len(args) == 2:
return matrix["%s|%s" % (args[0], args[1])]
elif len(args) == 1:
return matrix["%s" % (args[0])]
else:
raise Exception("Invalid argument list: " + str(args))
| {
"content_hash": "b940170b6f39e781d2b7838e71a58c43",
"timestamp": "",
"source": "github",
"line_count": 46,
"max_line_length": 75,
"avg_line_length": 30.456521739130434,
"alnum_prop": 0.5438972162740899,
"repo_name": "akullpp/ClusterPy",
"id": "dc5529defee43d430266ec3f6b6cda309f65a18a",
"size": "1401",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "src/utility.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "11009"
}
],
"symlink_target": ""
} |
"""
@package mi.dataset.driver.pco2w_abc.imodem
@file mi-dataset/mi/dataset/driver/pco2w_abc/imodem/pco2w_abc_imodem_recovered_driver.py
@author Mark Worden
@brief Driver for the pco2w_abc_imodem instrument
Release notes:
Initial Release
"""
from mi.dataset.dataset_parser import DataSetDriverConfigKeys
from mi.dataset.dataset_driver import SimpleDatasetDriver
from mi.dataset.parser.pco2w_abc_imodem import Pco2wAbcImodemParser
from mi.dataset.parser.pco2w_abc_particles import \
Pco2wAbcParticleClassKey, \
Pco2wAbcImodemInstrumentBlankRecoveredDataParticle, \
Pco2wAbcImodemInstrumentRecoveredDataParticle, \
Pco2wAbcImodemPowerRecoveredDataParticle, \
Pco2wAbcImodemControlRecoveredDataParticle, \
Pco2wAbcImodemMetadataRecoveredDataParticle
from mi.core.versioning import version
@version("15.6.0")
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
"""
This is the method called by Uframe
:param basePythonCodePath This is the file system location of mi-dataset
:param sourceFilePath This is the full path and filename of the file to be parsed
:param particleDataHdlrObj Java Object to consume the output of the parser
:return particleDataHdlrObj
"""
with open(sourceFilePath, 'rU') as stream_handle:
driver = Pco2wAbcImodemRecoveredDriver(basePythonCodePath, stream_handle, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
class Pco2wAbcImodemRecoveredDriver(SimpleDatasetDriver):
"""
All this needs to do is create a concrete _build_parser method
"""
def _build_parser(self, stream_handle):
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.pco2w_abc_particles',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
Pco2wAbcParticleClassKey.METADATA_PARTICLE_CLASS:
Pco2wAbcImodemMetadataRecoveredDataParticle,
Pco2wAbcParticleClassKey.POWER_PARTICLE_CLASS:
Pco2wAbcImodemPowerRecoveredDataParticle,
Pco2wAbcParticleClassKey.INSTRUMENT_PARTICLE_CLASS:
Pco2wAbcImodemInstrumentRecoveredDataParticle,
Pco2wAbcParticleClassKey.INSTRUMENT_BLANK_PARTICLE_CLASS:
Pco2wAbcImodemInstrumentBlankRecoveredDataParticle,
Pco2wAbcParticleClassKey.CONTROL_PARTICLE_CLASS:
Pco2wAbcImodemControlRecoveredDataParticle,
}
}
parser = Pco2wAbcImodemParser(parser_config,
stream_handle,
self._exception_callback)
return parser
| {
"content_hash": "b0932ffc4ce60922559fc523b77b2906",
"timestamp": "",
"source": "github",
"line_count": 71,
"max_line_length": 102,
"avg_line_length": 38.732394366197184,
"alnum_prop": 0.7232727272727273,
"repo_name": "JeffRoy/mi-dataset",
"id": "5f1479526d8c661c2495a177096ae9970017575f",
"size": "2773",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "mi/dataset/driver/pco2w_abc/imodem/pco2w_abc_imodem_recovered_driver.py",
"mode": "33188",
"license": "bsd-2-clause",
"language": [
{
"name": "Python",
"bytes": "3610231"
}
],
"symlink_target": ""
} |
from nose.tools import *
from game.bin.map import *
def test_room():
gold = Room("GoldRoom",
"""This room has gold in it you can grab. There's a
door to the north.""")
assert_equal(gold.name, "GoldRoom")
assert_equal(gold.paths, {})
def test_room_paths():
center = Room("Center", "Test room in the center.")
north = Room("North", "Test room in the north.")
south = Room("South", "Test room in the south.")
center.add_paths({'north': north, 'south': south})
assert_equal(center.go('north'), north)
assert_equal(center.go('south'), south)
def test_map():
start = Room("Start", "You can go west and down a hole.")
west = Room("Trees", "There are trees here, you can go east.")
down = Room("Dungeon", "It's dark down here, you can go up.")
start.add_paths({'west': west, 'down': down})
west.add_paths({'east': start})
down.add_paths({'up': start})
assert_equal(start.go('west'), west)
assert_equal(start.go('west').go('east'), start)
assert_equal(start.go('down').go('up'), start)
def test_gothon_game_map():
assert_equal(START.go('shoot!'), generic_death)
assert_equal(START.go('dodge!'), generic_death)
room = START.go('tell a joke')
assert_equal(room, laser_weapon_armory)
| {
"content_hash": "9e43afaf0672ba1038ef2b4f3ad3bbe1",
"timestamp": "",
"source": "github",
"line_count": 38,
"max_line_length": 67,
"avg_line_length": 34.21052631578947,
"alnum_prop": 0.6161538461538462,
"repo_name": "pwittchen/learn-python-the-hard-way",
"id": "6f69602289dda57334178dce9d8c58b3f4d4eb05",
"size": "1300",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "exercises/exercise52/game/tests/map_tests.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "HTML",
"bytes": "996"
},
{
"name": "Python",
"bytes": "62483"
},
{
"name": "Shell",
"bytes": "144"
}
],
"symlink_target": ""
} |
"""
A sub-package for efficiently dealing with polynomials.
Within the documentation for this sub-package, a "finite power series,"
i.e., a polynomial (also referred to simply as a "series") is represented
by a 1-D numpy array of the polynomial's coefficients, ordered from lowest
order term to highest. For example, array([1,2,3]) represents
``P_0 + 2*P_1 + 3*P_2``, where P_n is the n-th order basis polynomial
applicable to the specific module in question, e.g., `polynomial` (which
"wraps" the "standard" basis) or `chebyshev`. For optimal performance,
all operations on polynomials, including evaluation at an argument, are
implemented as operations on the coefficients. Additional (module-specific)
information can be found in the docstring for the module of interest.
"""
from __future__ import division, absolute_import, print_function
from .polynomial import Polynomial
from .chebyshev import Chebyshev
from .legendre import Legendre
from .hermite import Hermite
from .hermite_e import HermiteE
from .laguerre import Laguerre
from numpy.testing import _numpy_tester
test = _numpy_tester().test
bench = _numpy_tester().bench
| {
"content_hash": "1f11cf024934b300412120b3c85d834d",
"timestamp": "",
"source": "github",
"line_count": 27,
"max_line_length": 76,
"avg_line_length": 42.22222222222222,
"alnum_prop": 0.7736842105263158,
"repo_name": "ryfeus/lambda-packs",
"id": "ae5b1f078dd71da24bd974ca97c11f9ad362903a",
"size": "1140",
"binary": false,
"copies": "10",
"ref": "refs/heads/master",
"path": "Spacy/source2.7/numpy/polynomial/__init__.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "C",
"bytes": "9768343"
},
{
"name": "C++",
"bytes": "76566960"
},
{
"name": "CMake",
"bytes": "191097"
},
{
"name": "CSS",
"bytes": "153538"
},
{
"name": "Cuda",
"bytes": "61768"
},
{
"name": "Cython",
"bytes": "3110222"
},
{
"name": "Fortran",
"bytes": "110284"
},
{
"name": "HTML",
"bytes": "248658"
},
{
"name": "JavaScript",
"bytes": "62920"
},
{
"name": "MATLAB",
"bytes": "17384"
},
{
"name": "Makefile",
"bytes": "152150"
},
{
"name": "Python",
"bytes": "549307737"
},
{
"name": "Roff",
"bytes": "26398"
},
{
"name": "SWIG",
"bytes": "142"
},
{
"name": "Shell",
"bytes": "7790"
},
{
"name": "Smarty",
"bytes": "4090"
},
{
"name": "TeX",
"bytes": "152062"
},
{
"name": "XSLT",
"bytes": "305540"
}
],
"symlink_target": ""
} |
ID = "chatevent"
permission = 3
privmsgEnabled = False
def timer(self, channels):
self.sendChatMessage(self.send, channels[0], "pong")
def chatEvent(self, channels, userdata, message, currChannel):
#print channels
#print currChannel
if channels != False:
if currChannel in channels:
self.sendChatMessage(self.send, currChannel, str(len(message)))
if "start" in message:
self.sendChatMessage(self.send, currChannel, "Starting time event")
self.events["time"].addEvent("TimerTest", 10, timer, [currChannel], from_event = True)
if "end" in message:
self.sendChatMessage(self.send, currChannel, "Ending time event")
self.events["time"].removeEvent("TimerTest", from_event = True)
def execute(self, name, params, channel, userdata, rank):
#print "running"
if len(params) == 1 and params[0] == "on":
if not self.events["chat"].doesExist("TestFunc"):
self.sendChatMessage(self.send, channel, "Turning chatevent on.")
self.timerChannel = channel
self.events["chat"].addEvent("TestFunc", chatEvent)
else:
self.sendChatMessage(self.send, channel, "chatevent is already running.")
elif len(params) == 1 and params[0] == "off":
if self.events["chat"].doesExist("TestFunc"):
self.sendChatMessage(self.send, channel, "Turning chatevent off.")
self.events["chat"].removeEvent("TestFunc")
else:
self.sendChatMessage(self.send, channel, "chatevent isn't running!")
elif len(params) == 2 and params[0] == "add":
channel = self.retrieveTrueCase(params[1])
if channel != False:
self.sendChatMessage(self.send, channel, "added")
self.events["chat"].addChannel("TestFunc", channel)
elif len(params) == 2 and params[0] == "rem":
channel = self.retrieveTrueCase(params[1])
if channel != False:
self.sendChatMessage(self.send, channel, "removed")
self.events["chat"].removeChannel("TestFunc", channel) | {
"content_hash": "5583291cf43aa9db92b6e4cfdd3af3db",
"timestamp": "",
"source": "github",
"line_count": 52,
"max_line_length": 102,
"avg_line_length": 42.03846153846154,
"alnum_prop": 0.6052150045745655,
"repo_name": "NightKev/Renol-IRC",
"id": "a5e6824fd987336aff9007f95e0d05b73a9b4e3f",
"size": "2186",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "commands/example_chatAndTimerEventTest.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "201288"
}
],
"symlink_target": ""
} |
from __future__ import absolute_import
from __future__ import print_function
from spdx import checksum
from spdx import document
from spdx import utils
import hashlib
class FileType(object):
SOURCE = 1
BINARY = 2
ARCHIVE = 3
OTHER = 4
class File(object):
"""Representation of SPDX file.
Fields:
name - File name, str mandatory one.
comment - File comment str, Optional zero or one.
type - one of FileType.SOURCE, FileType.BINARY, FileType.ARCHIVE
and FileType.OTHER, optional zero or one.
chk_sum - SHA1, Mandatory one.
conc_lics - Mandatory one. document.License or utils.NoAssert or utils.SPDXNone.
licenses_in_file - list of licenses found in file, mandatory one or more.
document.License or utils.SPDXNone or utils.NoAssert.
document.license or utils.NoAssert or utils.SPDXNone.
license_comment - Optional.
copyright - Copyright text, Mandatory one. utils.NoAssert or utils.SPDXNone or str.
notice - optional One, str.
contributers - List of strings.
dependencies - list of file locations.
artifact_of_project_name - list of project names, possibly empty.
artifact_of_project_home - list of project home page, possibly empty.
artifact_of_project_uri - list of project uris, possibly empty.
"""
def __init__(self, name, chk_sum = None):
super(File, self).__init__()
self.name = name
self.comment = None
self.type = None
self.chk_sum = chk_sum
self.conc_lics = None
self.licenses_in_file = []
self.license_comment = None
self.copyright = None
self.notice = None
self.contributers = []
self.dependencies = []
self.artifact_of_project_name = []
self.artifact_of_project_home = []
self.artifact_of_project_uri = []
def add_lics(self, lics):
"""Appends lics to licenses_in_file."""
self.licenses_in_file.append(lics)
def add_contrib(self, contrib):
"""Appends contrib to contributers."""
self.contributers.append(contrib)
def add_depend(self, depend):
"""Appends depend to dependencies."""
self.dependencies.append(depend)
def add_artifact(self, symbol, value):
"""Adds value as artifact_of_project{symbol}."""
expr = 'self.artifact_of_project_{0}.append(value)'.format(symbol)
eval(expr)
def validate(self, messages):
"""Validates the fields and appends user friendly messages
to messages parameter if there are errors.
"""
return (self.validate_lic_conc(messages) and
self.validate_type(messages) and
self.validate_chksum(messages) and
self.validate_licenses_in_file(messages) and
self.validate_copyright(messages) and
self.validate_artifacts(messages))
def validate_copyright(self, messages):
if type(self.copyright) in [str, unicode, utils.NoAssert, utils.SPDXNone]:
return True
else:
messages.append('File copyright must be str or unicode or utils.NoAssert or utils.SPDXNone')
return False
def validate_artifacts(self, messages):
if (len(self.artifact_of_project_home) >=
max(len(self.artifact_of_project_uri), len(self.artifact_of_project_name))):
return True
else:
messages.append('File must have as much artifact of project as uri or homepage')
return False
def validate_licenses_in_file(self, messages):
if len(self.licenses_in_file) == 0:
messages.append('File must have at least one license in file.')
return False
else:
return True
def validate_lic_conc(self, messages):
if type(self.conc_lics) in [utils.NoAssert,
utils.SPDXNone] or isinstance(self.conc_lics, document.License):
return True
else:
messages.append('File concluded license must be one of document.License, utils.NoAssert or utils.SPDXNone')
return False
def validate_type(self, messages):
if self.type in [None, FileType.SOURCE, FileType.OTHER, FileType.BINARY,
FileType.ARCHIVE]:
return True
else:
messages.append('File type must be one of the constants defined in class spdx.file.FileType')
return False
def validate_chksum(self, messages):
if isinstance(self.chk_sum, checksum.Algorithm):
if self.chk_sum.identifier == 'SHA1':
return True
else:
messages.append('File checksum algorithm must be SHA1')
return False
else:
messages.append('File checksum must be instance of spdx.checksum.Algorithm')
return False
def calc_chksum(self):
BUFFER_SIZE = 65536
file_sha1 = hashlib.sha1()
with open(self.name, 'rb') as file_handle:
while True:
data = file_handle.read(BUFFER_SIZE)
if not data:
break
file_sha1.update(data)
return file_sha1.hexdigest()
def has_optional_field(self, field):
expr = 'self.{0} is not None'.format(field)
return eval(expr)
| {
"content_hash": "1f3f685b6021c72269f4732aee2559db",
"timestamp": "",
"source": "github",
"line_count": 150,
"max_line_length": 119,
"avg_line_length": 35.593333333333334,
"alnum_prop": 0.6210900917774864,
"repo_name": "bmwcarit/spdx-tools-python",
"id": "5613ea6835e49313639063f81e6e24f4ce170d5b",
"size": "5918",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "spdx/file.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Python",
"bytes": "331997"
}
],
"symlink_target": ""
} |
import numpy as np
class run:
def __init__(self,
instance):
#begin
print ' '
print 'normalize_by_negative_delay_points script running'
#create array to hold averages
positive_delay_averages = np.zeros(len(instance.xi))
#collect averages
cutoff = 80 #fs
positive_delay_averages = np.zeros(len(instance.xi))
for i in range(len(instance.xi)):
num_points = 0
current_slice_value = 0
for j in range(len(instance.yi)):
if instance.yi[j] > cutoff:
num_points = num_points + 1
current_slice_value = current_slice_value + instance.zi[j][i]
else:
pass
positive_delay_averages[i] = current_slice_value / num_points
#normalize by averages
for i in range(len(instance.xi)):
for j in range(len(instance.yi)):
instance.zi[j][i] = instance.zi[j][i] - positive_delay_averages[i]
#re-scale data zmin, zmax
instance.zmax = instance.zi.max()
instance.zmin = instance.zi.min()
instance.znull = 0
#finish
print ' done'
| {
"content_hash": "b3ba9a141d608e52625b6cb75a502c9e",
"timestamp": "",
"source": "github",
"line_count": 40,
"max_line_length": 82,
"avg_line_length": 33.4,
"alnum_prop": 0.49326347305389223,
"repo_name": "untzag/datplot",
"id": "68ba5c8e62260287f890987775935656d70a8c32",
"size": "1526",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "extensions/subtract_average_of_positive_points_along_y.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "C",
"bytes": "124949"
},
{
"name": "HTML",
"bytes": "3608947"
},
{
"name": "Makefile",
"bytes": "1513"
},
{
"name": "Python",
"bytes": "260766"
},
{
"name": "Shell",
"bytes": "620"
}
],
"symlink_target": ""
} |
from setuptools import setup, find_packages
setup(
name='wilmu-linux-toolkit',
version='0.0.14',
description='Linux toolkit for Wilmington University',
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Topic :: Utilities'
],
keywords='linux utility wilmu',
url='https://github.com/jpwhite3/wilmu-linux-toolkit',
author='JP White',
author_email='[email protected]',
license='MIT',
packages=find_packages(),
# install_requires=['requests', 'unittest2', 'importlib', 'colorama', 'pyfiglet', 'argparse'],
entry_points = {
'console_scripts': [
'checklab=lab_toolkit.command_line:checklab',
'submitlab=lab_toolkit.command_line:submitlab',
'update_toolkit=lab_toolkit.command_line:update_toolkit'
],
},
include_package_data=True,
zip_safe=False
) | {
"content_hash": "1081f0142bec9085fdf25706b8178a26",
"timestamp": "",
"source": "github",
"line_count": 30,
"max_line_length": 98,
"avg_line_length": 34.03333333333333,
"alnum_prop": 0.6209598432908913,
"repo_name": "jpwhite3/wilmu-linux-toolkit",
"id": "f0bf74b5cab4f104fe6cb7dcbabb1dde2da291cb",
"size": "1021",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "setup.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "PHP",
"bytes": "599"
},
{
"name": "Python",
"bytes": "1842104"
},
{
"name": "Shell",
"bytes": "4449"
}
],
"symlink_target": ""
} |
from ._models_py3 import ElasticSan
from ._models_py3 import ElasticSanList
from ._models_py3 import ElasticSanOperationDisplay
from ._models_py3 import ElasticSanOperationListResult
from ._models_py3 import ElasticSanRPOperation
from ._models_py3 import ElasticSanUpdate
from ._models_py3 import Error
from ._models_py3 import ErrorAdditionalInfo
from ._models_py3 import ErrorResponse
from ._models_py3 import IscsiTargetInfo
from ._models_py3 import NetworkRuleSet
from ._models_py3 import Resource
from ._models_py3 import SKUCapability
from ._models_py3 import Sku
from ._models_py3 import SkuInformation
from ._models_py3 import SkuInformationList
from ._models_py3 import SkuLocationInfo
from ._models_py3 import SourceCreationData
from ._models_py3 import SystemData
from ._models_py3 import TrackedResource
from ._models_py3 import VirtualNetworkRule
from ._models_py3 import Volume
from ._models_py3 import VolumeGroup
from ._models_py3 import VolumeGroupList
from ._models_py3 import VolumeGroupUpdate
from ._models_py3 import VolumeList
from ._models_py3 import VolumeUpdate
from ._elastic_san_management_enums import CreatedByType
from ._elastic_san_management_enums import EncryptionType
from ._elastic_san_management_enums import OperationalStatus
from ._elastic_san_management_enums import ProvisioningStates
from ._elastic_san_management_enums import SkuName
from ._elastic_san_management_enums import SkuTier
from ._elastic_san_management_enums import State
from ._elastic_san_management_enums import StorageTargetType
from ._patch import __all__ as _patch_all
from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import
from ._patch import patch_sdk as _patch_sdk
__all__ = [
"ElasticSan",
"ElasticSanList",
"ElasticSanOperationDisplay",
"ElasticSanOperationListResult",
"ElasticSanRPOperation",
"ElasticSanUpdate",
"Error",
"ErrorAdditionalInfo",
"ErrorResponse",
"IscsiTargetInfo",
"NetworkRuleSet",
"Resource",
"SKUCapability",
"Sku",
"SkuInformation",
"SkuInformationList",
"SkuLocationInfo",
"SourceCreationData",
"SystemData",
"TrackedResource",
"VirtualNetworkRule",
"Volume",
"VolumeGroup",
"VolumeGroupList",
"VolumeGroupUpdate",
"VolumeList",
"VolumeUpdate",
"CreatedByType",
"EncryptionType",
"OperationalStatus",
"ProvisioningStates",
"SkuName",
"SkuTier",
"State",
"StorageTargetType",
]
__all__.extend([p for p in _patch_all if p not in __all__])
_patch_sdk()
| {
"content_hash": "2080a08cfe8c0a95c40949af986f164d",
"timestamp": "",
"source": "github",
"line_count": 79,
"max_line_length": 78,
"avg_line_length": 32.32911392405063,
"alnum_prop": 0.7533281127642913,
"repo_name": "Azure/azure-sdk-for-python",
"id": "760d42042c24a6d77f223fcfa56058c288e567b2",
"size": "3022",
"binary": false,
"copies": "1",
"ref": "refs/heads/main",
"path": "sdk/elasticsan/azure-mgmt-elasticsan/azure/mgmt/elasticsan/models/__init__.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Batchfile",
"bytes": "1224"
},
{
"name": "Bicep",
"bytes": "24196"
},
{
"name": "CSS",
"bytes": "6089"
},
{
"name": "Dockerfile",
"bytes": "4892"
},
{
"name": "HTML",
"bytes": "12058"
},
{
"name": "JavaScript",
"bytes": "8137"
},
{
"name": "Jinja",
"bytes": "10377"
},
{
"name": "Jupyter Notebook",
"bytes": "272022"
},
{
"name": "PowerShell",
"bytes": "518535"
},
{
"name": "Python",
"bytes": "715484989"
},
{
"name": "Shell",
"bytes": "3631"
}
],
"symlink_target": ""
} |
import lintreview.github as github
import logging
log = logging.getLogger(__name__)
class GithubRepository(object):
"""Abstracting wrapper for the
various interactions we have with github.
This will make swapping in other hosting systems
a tiny bit easier in the future.
"""
def __init__(self, config, user, repo_name):
self.config = config
self.user = user
self.repo_name = repo_name
def repository(self):
"""Get the underlying repository model
"""
self.repo = github.get_repository(
self.config,
self.user,
self.repo_name)
return self.repo
def pull_request(self, number):
"""Get a pull request by number.
"""
pull = self.repository().pull_request(number)
return GithubPullRequest(pull)
def ensure_label(self, label):
"""Create label if it doesn't exist yet
"""
repo = self.repository()
if not repo.label(label):
repo.create_label(
name=label,
color="bfe5bf", # a nice light green
)
def create_status(self, sha, state, description):
"""Create a commit status
"""
context = self.config.get('APP_NAME', 'lintreview')
repo = self.repository()
repo.create_status(
sha,
state,
None,
description,
context)
class GithubPullRequest(object):
"""Abstract the underlying github models.
This makes other code simpler, and enables
the ability to add other hosting services later.
"""
def __init__(self, pull_request):
self.pull = pull_request
@property
def display_name(self):
data = self.pull.as_dict()
return u'%s#%s' % (data['head']['repo']['full_name'],
data['number'])
@property
def number(self):
return self.pull.number
@property
def is_private(self):
data = self.pull.as_dict()
return data['head']['repo']['private']
@property
def head(self):
data = self.pull.as_dict()
return data['head']['sha']
@property
def clone_url(self):
data = self.pull.as_dict()
return data['head']['repo']['clone_url']
@property
def base_repo_url(self):
data = self.pull.as_dict()
return data['base']['repo']['clone_url']
@property
def target_branch(self):
data = self.pull.as_dict()
return data['base']['ref']
def commits(self):
return self.pull.commits()
def review_comments(self):
return self.pull.review_comments()
def files(self):
return list(self.pull.files())
def remove_label(self, label_name):
issue = self.pull.issue()
labels = issue.labels()
if not any(label_name == label.name for label in labels):
return
log.debug("Removing issue label '%s'", label_name)
issue.remove_label(label_name)
def add_label(self, label_name):
issue = self.pull.issue()
issue.add_labels(label_name)
def create_comment(self, body):
self.pull.create_comment(body)
def create_review_comment(self, body, commit_id, path, position):
self.pull.create_review_comment(body, commit_id, path, position)
| {
"content_hash": "cce24cb359fe1d66f9f6558842234217",
"timestamp": "",
"source": "github",
"line_count": 127,
"max_line_length": 72,
"avg_line_length": 26.64566929133858,
"alnum_prop": 0.5750591016548463,
"repo_name": "adrianmoisey/lint-review",
"id": "3fba7c2aa718316640ab61895515aff4a6a0294d",
"size": "3384",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "lintreview/repo.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "177403"
},
{
"name": "Ruby",
"bytes": "1057"
}
],
"symlink_target": ""
} |
import logging, time
from logic.smboolmanager import SMBoolManagerPlando as SMBoolManager
from logic.smbool import SMBool, smboolFalse
from logic.helpers import Bosses
from rom.romloader import RomLoader
from rom.rom_patches import RomPatches
from graph.graph import AccessGraphSolver as AccessGraph
from utils.utils import PresetLoader
from solver.conf import Conf
from graph.graph_utils import vanillaTransitions, vanillaBossesTransitions, vanillaEscapeTransitions, GraphUtils, getAccessPoint
from utils.parameters import easy, medium, hard, harder, hardcore, mania, infinity
from utils.doorsmanager import DoorsManager
from utils.objectives import Objectives
from logic.logic import Logic
from graph.location import define_location
class CommonSolver(object):
def loadRom(self, rom, interactive=False, magic=None, startLocation=None):
self.scavengerOrder = []
self.plandoScavengerOrder = []
self.additionalETanks = 0
# startLocation param is only use for seedless
if rom is None:
# TODO::add a --logic parameter for seedless
Logic.factory('vanilla')
self.romFileName = 'seedless'
self.majorsSplit = 'Full'
self.masterMajorsSplit = 'Full'
self.areaRando = True
self.bossRando = True
self.escapeRando = False
self.escapeTimer = "03:00"
self.startLocation = startLocation
RomPatches.setDefaultPatches(startLocation)
self.startArea = getAccessPoint(startLocation).Start['solveArea']
# in seedless load all the vanilla transitions
self.areaTransitions = vanillaTransitions[:]
self.bossTransitions = vanillaBossesTransitions[:]
self.escapeTransition = [vanillaEscapeTransitions[0]]
# in seedless we allow mixing of area and boss transitions
self.hasMixedTransitions = True
self.curGraphTransitions = self.bossTransitions + self.areaTransitions + self.escapeTransition
self.locations = Logic.locations
for loc in self.locations:
loc.itemName = 'Nothing'
# set doors related to default patches
DoorsManager.setDoorsColor()
self.doorsRando = False
self.hasNothing = False
self.objectives.setVanilla()
self.tourian = 'Vanilla'
self.majorUpgrades = []
self.splitLocsByArea = {}
else:
self.romFileName = rom
self.romLoader = RomLoader.factory(rom, magic)
Logic.factory(self.romLoader.readLogic())
self.romLoader.loadSymbols()
self.locations = Logic.locations
(self.majorsSplit, self.masterMajorsSplit) = self.romLoader.assignItems(self.locations)
(self.startLocation, self.startArea, startPatches) = self.romLoader.getStartAP()
if not GraphUtils.isStandardStart(self.startLocation) and self.majorsSplit != 'Full':
# update major/chozo locs in non standard start
self.romLoader.updateSplitLocs(self.majorsSplit, self.locations)
(self.areaRando, self.bossRando, self.escapeRando, hasObjectives, self.tourian) = self.romLoader.loadPatches()
RomPatches.ActivePatches += startPatches
self.escapeTimer = self.romLoader.getEscapeTimer()
self.doorsRando = self.romLoader.loadDoorsColor()
self.hasNothing = self.checkLocsForNothing()
if self.majorsSplit == 'Scavenger':
self.scavengerOrder = self.romLoader.loadScavengerOrder(self.locations)
if hasObjectives:
self.romLoader.loadObjectives(self.objectives)
if interactive:
# load event bit masks for auto tracker
self.eventsBitMasks = self.romLoader.loadEventBitMasks()
else:
if self.majorsSplit == "Scavenger":
# add scav hunt
self.objectives.setScavengerHunt()
self.objectives.tourianRequired = not bool(self.romLoader.readOption('escapeTrigger'))
if self.objectives.tourianRequired:
# add G4 on top of scav hunt
self.objectives.setVanilla()
else:
# only G4
self.objectives.setVanilla()
self.majorUpgrades = self.romLoader.loadMajorUpgrades()
self.splitLocsByArea = self.romLoader.getSplitLocsByArea(self.locations)
self.objectives.setSolverMode(self)
if self.mode == 'plando':
self.additionalETanks = self.romLoader.getAdditionalEtanks()
if interactive == False:
print("ROM {}\nmajors: {} area: {} boss: {} escape: {}\npatches: {}".format(rom, self.majorsSplit, self.areaRando, self.bossRando, self.escapeRando, sorted(self.romLoader.getPatches())))
else:
print("majors: {} area: {} boss: {} escape: {}".format(self.majorsSplit, self.areaRando, self.bossRando, self.escapeRando))
(self.areaTransitions, self.bossTransitions, self.escapeTransition, self.hasMixedTransitions) = self.romLoader.getTransitions(self.tourian)
if interactive == True and self.debug == False:
# in interactive area mode we build the graph as we play along
if self.areaRando == True and self.bossRando == True:
self.curGraphTransitions = []
elif self.areaRando == True:
self.curGraphTransitions = self.bossTransitions[:]
elif self.bossRando == True:
self.curGraphTransitions = self.areaTransitions[:]
else:
self.curGraphTransitions = self.bossTransitions + self.areaTransitions
if self.escapeRando == False:
self.curGraphTransitions += self.escapeTransition
else:
self.curGraphTransitions = self.bossTransitions + self.areaTransitions + self.escapeTransition
self.smbm = SMBoolManager()
self.buildGraph()
# store at each step how many locations are available
self.nbAvailLocs = []
if self.log.getEffectiveLevel() == logging.DEBUG:
self.log.debug("Display items at locations:")
for loc in self.locations:
self.log.debug('{:>50}: {:>16}'.format(loc.Name, loc.itemName))
def buildGraph(self):
self.areaGraph = AccessGraph(Logic.accessPoints, self.curGraphTransitions)
Objectives.setGraph(self.areaGraph, infinity)
def loadPreset(self, presetFileName):
presetLoader = PresetLoader.factory(presetFileName)
presetLoader.load()
self.smbm.createKnowsFunctions()
if self.log.getEffectiveLevel() == logging.DEBUG:
presetLoader.printToScreen()
def getLoc(self, locName):
for loc in self.locations:
if loc.Name == locName:
return loc
def getNextDifficulty(self, difficulty):
nextDiffs = {
0: easy,
easy: medium,
medium: hard,
hard: harder,
harder: hardcore,
hardcore: mania,
mania: infinity
}
return nextDiffs[difficulty]
def checkLocsForNothing(self):
# for the auto tracker, need to know if we have to track nothing items
return any(loc.itemName == "Nothing" for loc in self.locations)
def computeLocationsDifficulty(self, locations, phase="major"):
difficultyTarget = Conf.difficultyTarget
nextLocations = locations
# before looping on all diff targets, get only the available locations with diff target infinity
if difficultyTarget != infinity:
self.areaGraph.getAvailableLocations(nextLocations, self.smbm, infinity, self.lastAP)
nextLocations = [loc for loc in nextLocations if loc.difficulty]
while True:
self.areaGraph.getAvailableLocations(nextLocations, self.smbm, difficultyTarget, self.lastAP)
# check post available functions too
for loc in nextLocations:
loc.evalPostAvailable(self.smbm)
self.areaGraph.useCache(True)
# also check if we can come back to current AP from the location
for loc in nextLocations:
loc.evalComeBack(self.smbm, self.areaGraph, self.lastAP)
self.areaGraph.useCache(False)
nextLocations = [loc for loc in nextLocations if not loc.difficulty]
if not nextLocations:
break
if difficultyTarget == infinity:
# we've tested all the difficulties
break
# start a new loop with next difficulty
difficultyTarget = self.getNextDifficulty(difficultyTarget)
if self.log.getEffectiveLevel() == logging.DEBUG:
self.log.debug("available {} locs:".format(phase))
for loc in locations:
if loc.difficulty.bool == True:
print("{:>48}: {:>8}".format(loc.Name, round(loc.difficulty.difficulty, 2)))
print(" smbool: {}".format(loc.difficulty))
print(" path: {}".format([ap.Name for ap in loc.path]))
def collectMajor(self, loc, itemName=None):
self.majorLocations.remove(loc)
self.visitedLocations.append(loc)
self.collectItem(loc, itemName)
return loc
def collectMinor(self, loc):
self.minorLocations.remove(loc)
self.visitedLocations.append(loc)
self.collectItem(loc)
return loc
def collectItem(self, loc, item=None):
if item == None:
item = loc.itemName
if self.vcr != None:
self.vcr.addLocation(loc.Name, item)
if self.firstLogFile is not None:
if item not in self.collectedItems:
self.firstLogFile.write("{};{};{};{}\n".format(item, loc.Name, loc.Area, loc.GraphArea))
if item not in Conf.itemsForbidden:
self.collectedItems.append(item)
if self.checkDuplicateMajor == True:
if item not in ['Nothing', 'NoEnergy', 'Missile', 'Super', 'PowerBomb', 'ETank', 'Reserve']:
if self.smbm.haveItem(item):
print("WARNING: {} has already been picked up".format(item))
self.smbm.addItem(item)
else:
# update the name of the item
item = "-{}-".format(item)
loc.itemName = item
self.collectedItems.append(item)
# we still need the boss difficulty
if not loc.isBoss():
loc.difficulty = smboolFalse
if self.log.getEffectiveLevel() == logging.DEBUG:
print("---------------------------------------------------------------")
print("collectItem: {:<16} at {:<48} diff {}".format(item, loc.Name, loc.difficulty))
print("---------------------------------------------------------------")
# last loc is used as root node for the graph.
# when loading a plando we can load locations from non connected areas, so they don't have an access point.
if loc.accessPoint is not None:
self.lastAP = loc.accessPoint
self.lastArea = loc.SolveArea
def getLocIndex(self, locName):
for (i, loc) in enumerate(self.visitedLocations):
if loc.Name == locName:
return i
def removeItemAt(self, locNameWeb):
locName = self.locNameWeb2Internal(locNameWeb)
locIndex = self.getLocIndex(locName)
if locIndex is None:
self.errorMsg = "Location '{}' has not been visited".format(locName)
return
loc = self.visitedLocations.pop(locIndex)
# removeItemAt is only used from the tracker, so all the locs are in majorLocations
self.majorLocations.append(loc)
# access point
if len(self.visitedLocations) == 0:
self.lastAP = self.startLocation
self.lastArea = self.startArea
else:
self.lastAP = self.visitedLocations[-1].accessPoint
self.lastArea = self.visitedLocations[-1].SolveArea
# delete location params which are set when the location is available
if loc.difficulty is not None:
loc.difficulty = None
if loc.distance is not None:
loc.distance = None
if loc.accessPoint is not None:
loc.accessPoint = None
if loc.path is not None:
loc.path = None
# item
item = loc.itemName
if self.mode in ['seedless', 'race', 'debug']:
# in seedless remove the first nothing found as collectedItems is not ordered
self.collectedItems.remove(item)
else:
self.collectedItems.pop(locIndex)
# if multiple majors in plando mode, remove it from smbm only when it's the last occurence of it
if self.smbm.isCountItem(item):
self.smbm.removeItem(item)
else:
if item not in self.collectedItems:
self.smbm.removeItem(item)
def cancelLastItems(self, count):
if self.vcr != None:
self.vcr.addRollback(count)
if self.interactive == False:
self.nbAvailLocs = self.nbAvailLocs[:-count]
for _ in range(count):
if len(self.visitedLocations) == 0:
return
loc = self.visitedLocations.pop()
if self.majorsSplit == 'Full' or loc.isClass(self.majorsSplit) or loc.isBoss():
self.majorLocations.append(loc)
else:
self.minorLocations.append(loc)
# access point
if len(self.visitedLocations) == 0:
self.lastAP = self.startLocation
self.lastArea = self.startArea
else:
self.lastAP = self.visitedLocations[-1].accessPoint
if self.lastAP is None:
# default to location first access from access point
self.lastAP = list(self.visitedLocations[-1].AccessFrom.keys())[0]
self.lastArea = self.visitedLocations[-1].SolveArea
# delete location params which are set when the location is available
if loc.difficulty is not None:
loc.difficulty = None
if loc.distance is not None:
loc.distance = None
if loc.accessPoint is not None:
loc.accessPoint = None
if loc.path is not None:
loc.path = None
# item
item = loc.itemName
if item == self.collectedItems[-1]:
self.collectedItems.pop()
else:
raise Exception("Item of last collected loc {}: {} is different from last collected item: {}".format(loc.Name, item, self.collectedItems[-1]))
# in plando we have to remove the last added item,
# else it could be used in computing the postAvailable of a location
if self.mode in ['plando', 'seedless', 'race', 'debug']:
loc.itemName = 'Nothing'
# if multiple majors in plando mode, remove it from smbm only when it's the last occurence of it
if self.smbm.isCountItem(item):
self.smbm.removeItem(item)
else:
if item not in self.collectedItems:
self.smbm.removeItem(item)
def cancelObjectives(self, cur):
while self.completedObjectives and self.completedObjectives[-1][0] > cur:
goalCur, goalName = self.completedObjectives.pop()
self.log.debug("rollback objective {}".format(goalName))
self.objectives.setGoalCompleted(goalName, False)
def printLocs(self, locs, phase):
if len(locs) > 0:
print("{}:".format(phase))
print('{:>48} {:>12} {:>8} {:>8} {:>34} {:>10}'.format("Location Name", "Difficulty", "Distance", "ComeBack", "SolveArea", "AreaWeight"))
for loc in locs:
print('{:>48} {:>12} {:>8} {:>8} {:>34} {:>10}'.
format(loc.Name, round(loc.difficulty[1], 2), round(loc.distance, 2),
loc.comeBack, loc.SolveArea, loc.areaWeight if loc.areaWeight is not None else -1))
def getAvailableItemsList(self, locations, threshold):
# locations without distance are not available
locations = [loc for loc in locations if loc.distance is not None]
if len(locations) == 0:
return []
mandatoryBosses = Objectives.getMandatoryBosses()
# add nocomeback locations which has been selected by the comeback step (areaWeight == 1)
around = [loc for loc in locations if( (loc.areaWeight is not None and loc.areaWeight == 1)
or ((loc.SolveArea == self.lastArea or loc.distance < 3)
and loc.difficulty.difficulty <= threshold
and (not Bosses.areaBossDead(self.smbm, self.lastArea)
and (self.lastArea not in Bosses.areaBosses
or Bosses.areaBosses[self.lastArea] in mandatoryBosses))
and loc.comeBack is not None and loc.comeBack == True)
or (loc.Name == self.escapeLocName) )]
outside = [loc for loc in locations if not loc in around]
if self.log.getEffectiveLevel() == logging.DEBUG:
self.printLocs(around, "around1")
self.printLocs(outside, "outside1")
around.sort(key=lambda loc: (
# end game loc
0 if loc.Name == self.escapeLocName else 1,
# locs in the same area
0 if loc.SolveArea == self.lastArea else 1,
# nearest locs
loc.distance,
# beating a boss
0 if loc.isBoss() else 1,
# easiest first
loc.difficulty.difficulty
)
)
if self.log.getEffectiveLevel() == logging.DEBUG:
self.printLocs(around, "around2")
# we want to sort the outside locations by putting the ones in the same area first,
# then we sort the remaining areas starting whith boss dead status.
# we also want to sort by range of difficulty and not only with the difficulty threshold.
ranged = {
"areaWeight": [],
"easy": [],
"medium": [],
"hard": [],
"harder": [],
"hardcore": [],
"mania": [],
"noComeBack": []
}
for loc in outside:
if loc.areaWeight is not None:
ranged["areaWeight"].append(loc)
elif loc.comeBack is None or loc.comeBack == False:
ranged["noComeBack"].append(loc)
else:
difficulty = loc.difficulty.difficulty
if difficulty < medium:
ranged["easy"].append(loc)
elif difficulty < hard:
ranged["medium"].append(loc)
elif difficulty < harder:
ranged["hard"].append(loc)
elif difficulty < hardcore:
ranged["harder"].append(loc)
elif difficulty < mania:
ranged["hardcore"].append(loc)
else:
ranged["mania"].append(loc)
for key in ranged:
ranged[key].sort(key=lambda loc: (
# first locs in the same area
0 if loc.SolveArea == self.lastArea else 1,
# first nearest locs
loc.distance,
# beating a boss
loc.difficulty.difficulty if (not Bosses.areaBossDead(self.smbm, loc.Area)
and loc.isBoss())
else 100000,
# areas with boss still alive
loc.difficulty.difficulty if (not Bosses.areaBossDead(self.smbm, loc.Area))
else 100000,
loc.difficulty.difficulty))
if self.log.getEffectiveLevel() == logging.DEBUG:
for key in ["areaWeight", "easy", "medium", "hard", "harder", "hardcore", "mania", "noComeBack"]:
self.printLocs(ranged[key], "outside2:{}".format(key))
outside = []
for key in ["areaWeight", "easy", "medium", "hard", "harder", "hardcore", "mania", "noComeBack"]:
outside += ranged[key]
locs = around + outside
# special case for newbie like presets and VARIA tweaks, when both Phantoon and WS Etank are available,
# if phantoon is visited first then WS Etank is no longer available as newbie can't pass sponge bath.
# do the switch only if phantoon and ws etank have the same comeback, in boss rando we can have
# phantoon comeback and ws etank nocomeback and it would fail to solve in that case.
if locs and locs[0].Name == 'Phantoon':
for i, loc in enumerate(locs):
if loc.Name == 'Energy Tank, Wrecked Ship' and locs[0].comeBack == loc.comeBack:
self.log.debug("switch Phantoon and WS Etank")
locs[i] = locs[0]
locs[0] = loc
break
return locs
def nextDecision(self, majorsAvailable, minorsAvailable, hasEnoughMinors, diffThreshold):
# first take end game location to end the run
if (len(majorsAvailable) > 0
and majorsAvailable[0].Name == self.escapeLocName):
return self.collectMajor(majorsAvailable.pop(0))
# next take major items of acceptable difficulty in the current area
elif (len(majorsAvailable) > 0
and majorsAvailable[0].SolveArea == self.lastArea
and majorsAvailable[0].difficulty.difficulty <= diffThreshold
and majorsAvailable[0].comeBack == True):
return self.collectMajor(majorsAvailable.pop(0))
# next item decision
elif len(minorsAvailable) == 0 and len(majorsAvailable) > 0:
self.log.debug('MAJOR')
return self.collectMajor(majorsAvailable.pop(0))
elif len(majorsAvailable) == 0 and len(minorsAvailable) > 0:
# we don't check for hasEnoughMinors here, because we would be stuck, so pickup
# what we can and hope it gets better
self.log.debug('MINOR')
return self.collectMinor(minorsAvailable.pop(0))
elif len(majorsAvailable) > 0 and len(minorsAvailable) > 0:
self.log.debug('BOTH|M={}, m={}'.format(majorsAvailable[0].Name, minorsAvailable[0].Name))
# if both are available, decide based on area, difficulty and comeBack
nextMajDifficulty = majorsAvailable[0].difficulty.difficulty
nextMinDifficulty = minorsAvailable[0].difficulty.difficulty
nextMajArea = majorsAvailable[0].SolveArea
nextMinArea = minorsAvailable[0].SolveArea
nextMajComeBack = majorsAvailable[0].comeBack
nextMinComeBack = minorsAvailable[0].comeBack
nextMajDistance = majorsAvailable[0].distance
nextMinDistance = minorsAvailable[0].distance
maxAreaWeigth = 10000
nextMajAreaWeight = majorsAvailable[0].areaWeight if majorsAvailable[0].areaWeight is not None else maxAreaWeigth
nextMinAreaWeight = minorsAvailable[0].areaWeight if minorsAvailable[0] .areaWeight is not None else maxAreaWeigth
if self.log.getEffectiveLevel() == logging.DEBUG:
print(" : {:>4} {:>32} {:>4} {:>4} {:>6}".format("diff", "area", "back", "dist", "weight"))
print("major: {:>4} {:>32} {:>4} {:>4} {:>6}".format(round(nextMajDifficulty, 2), nextMajArea, nextMajComeBack, round(nextMajDistance, 2), nextMajAreaWeight))
print("minor: {:>4} {:>32} {:>4} {:>4} {:>6}".format(round(nextMinDifficulty, 2), nextMinArea, nextMinComeBack, round(nextMinDistance, 2), nextMinAreaWeight))
if hasEnoughMinors == True and self.haveAllMinorTypes() == True and self.smbm.haveItem('Charge') and nextMajAreaWeight != maxAreaWeigth:
# we have charge, no longer need minors
self.log.debug("we have charge, no longer need minors, take major")
return self.collectMajor(majorsAvailable.pop(0))
else:
# respect areaweight first
if nextMajAreaWeight != nextMinAreaWeight:
self.log.debug("maj/min != area weight")
if nextMajAreaWeight < nextMinAreaWeight:
return self.collectMajor(majorsAvailable.pop(0))
else:
return self.collectMinor(minorsAvailable.pop(0))
# then take item from loc where you can come back
elif nextMajComeBack != nextMinComeBack:
self.log.debug("maj/min != combeback")
if nextMajComeBack == True:
return self.collectMajor(majorsAvailable.pop(0))
else:
return self.collectMinor(minorsAvailable.pop(0))
# difficulty over area (this is a difficulty estimator, not a speedrunning simulator)
elif nextMinDifficulty <= diffThreshold and nextMajDifficulty <= diffThreshold:
# take the closer one
if nextMajDistance != nextMinDistance:
self.log.debug("!= distance and <= diffThreshold")
if nextMajDistance < nextMinDistance:
return self.collectMajor(majorsAvailable.pop(0))
else:
return self.collectMinor(minorsAvailable.pop(0))
# take the easier
elif nextMinDifficulty < nextMajDifficulty:
self.log.debug("min easier and not enough minors")
return self.collectMinor(minorsAvailable.pop(0))
elif nextMajDifficulty < nextMinDifficulty:
self.log.debug("maj easier")
return self.collectMajor(majorsAvailable.pop(0))
# same difficulty and distance for minor and major, take major first
else:
return self.collectMajor(majorsAvailable.pop(0))
# if not all the minors type are collected, start with minors
elif nextMinDifficulty <= diffThreshold and not self.haveAllMinorTypes():
self.log.debug("not all minors types")
return self.collectMinor(minorsAvailable.pop(0))
elif nextMinArea == self.lastArea and nextMinDifficulty <= diffThreshold:
self.log.debug("not enough minors")
return self.collectMinor(minorsAvailable.pop(0))
elif nextMinDifficulty > diffThreshold and nextMajDifficulty > diffThreshold:
# take the easier
if nextMinDifficulty < nextMajDifficulty:
self.log.debug("min easier and not enough minors")
return self.collectMinor(minorsAvailable.pop(0))
elif nextMajDifficulty < nextMinDifficulty:
self.log.debug("maj easier")
return self.collectMajor(majorsAvailable.pop(0))
# take the closer one
elif nextMajDistance != nextMinDistance:
self.log.debug("!= distance and > diffThreshold")
if nextMajDistance < nextMinDistance:
return self.collectMajor(majorsAvailable.pop(0))
else:
return self.collectMinor(minorsAvailable.pop(0))
# same difficulty and distance for minor and major, take major first
else:
return self.collectMajor(majorsAvailable.pop(0))
else:
if nextMinDifficulty < nextMajDifficulty:
self.log.debug("min easier and not enough minors")
return self.collectMinor(minorsAvailable.pop(0))
else:
self.log.debug("maj easier")
return self.collectMajor(majorsAvailable.pop(0))
raise Exception("Can't take a decision")
def canRelaxEnd(self):
# sometimes you can't get all locations because of restricted locs, so allow to go to mother brain
if self.endGameLoc.Name == 'Mother Brain' and Conf.itemsPickup == 'all':
self.relaxedEndCheck = True
self.computeLocationsDifficulty(self.majorLocations)
self.relaxedEndCheck = False
return self.endGameLoc.difficulty == True
else:
return False
def getGunship(self):
# add gunship location and try to go back to it
solver = self
def GunshipAccess(sm):
nonlocal solver
return SMBool(solver.objectives.allGoalsCompleted())
def GunshipAvailable(_, sm):
nonlocal solver
if solver.relaxedEndCheck:
return SMBool(True)
else:
hasEnoughMinors = solver.pickup.enoughMinors(sm, solver.minorLocations)
hasEnoughMajors = solver.pickup.enoughMajors(sm, solver.majorLocations)
hasEnoughItems = hasEnoughMajors and hasEnoughMinors
return SMBool(hasEnoughItems)
gunship = define_location(
Area="Crateria",
GraphArea="Crateria",
SolveArea="Crateria Landing Site",
Name="Gunship",
# to display bigger gunship image in spoiler log
Class=["Boss"],
CanHidden=False,
Address=-1,
Id=None,
Visibility="Hidden",
Room='Landing Site',
AccessFrom = {
'Landing Site': GunshipAccess
},
Available = GunshipAvailable
)
gunship.itemName = 'Gunship'
return gunship
def computeDifficulty(self):
# loop on the available locations depending on the collected items.
# before getting a new item, loop on all of them and get their difficulty,
# the next collected item is the one with the smallest difficulty,
# if equality between major and minor, take major first.
mbLoc = self.getLoc('Mother Brain')
if self.objectives.tourianRequired:
# update mother brain to handle all end game conditions, allow MB loc to access solver data
solver = self
def MotherBrainAccess(sm):
nonlocal solver
return SMBool(solver.objectives.allGoalsCompleted())
def MotherBrainAvailable(sm):
nonlocal solver
tourian = sm.enoughStuffTourian()
# can't check all locations
if solver.relaxedEndCheck:
return tourian
else:
hasEnoughMinors = solver.pickup.enoughMinors(sm, solver.minorLocations)
hasEnoughMajors = solver.pickup.enoughMajors(sm, solver.majorLocations)
hasEnoughItems = hasEnoughMajors and hasEnoughMinors
return sm.wand(tourian, SMBool(hasEnoughItems))
mbLoc.AccessFrom['Golden Four'] = MotherBrainAccess
mbLoc.Available = MotherBrainAvailable
self.endGameLoc = mbLoc
self.escapeLocName = 'Mother Brain'
else:
# remove mother brain location and replace it with gunship loc
self.locations.remove(mbLoc)
gunship = self.getGunship()
self.locations.append(gunship)
self.endGameLoc = gunship
self.escapeLocName = 'Gunship'
if self.majorsSplit == 'Major':
self.majorLocations = [loc for loc in self.locations if loc.isMajor() or loc.isBoss()]
self.minorLocations = [loc for loc in self.locations if loc.isMinor()]
elif self.majorsSplit == 'Chozo':
self.majorLocations = [loc for loc in self.locations if loc.isChozo() or loc.isBoss()]
self.minorLocations = [loc for loc in self.locations if not loc.isChozo() and not loc.isBoss()]
elif self.majorsSplit == 'Scavenger':
self.majorLocations = [loc for loc in self.locations if loc.isScavenger() or loc.isBoss()]
self.minorLocations = [loc for loc in self.locations if not loc.isScavenger() and not loc.isBoss()]
else:
# Full
self.majorLocations = self.locations[:] # copy
self.minorLocations = self.majorLocations
self.visitedLocations = []
self.collectedItems = []
self.log.debug("{}: available major: {}, available minor: {}, visited: {}".format(Conf.itemsPickup, len(self.majorLocations), len(self.minorLocations), len(self.visitedLocations)))
endDifficulty = mania
diffThreshold = self.getDiffThreshold()
self.relaxedEndCheck = False
self.aborted = False
self.completedObjectives = []
while self.endGameLoc not in self.visitedLocations:
# check time limit
if self.runtimeLimit_s > 0:
if time.process_time() - self.startTime > self.runtimeLimit_s:
self.log.debug("time limit exceeded ({})".format(self.runtimeLimit_s))
return (-1, False)
self.log.debug("Current AP/Area: {}/{}".format(self.lastAP, self.lastArea))
# check if a new objective can be completed
goals = self.objectives.checkGoals(self.smbm, self.lastAP)
if any([possible for possible in goals.values()]):
for goalName, possible in goals.items():
if possible:
self.log.debug("complete objective {}".format(goalName))
self.objectives.setGoalCompleted(goalName, True)
self.completedObjectives.append((len(self.collectedItems), goalName))
break
continue
# compute the difficulty of all the locations
self.computeLocationsDifficulty(self.majorLocations)
if self.majorsSplit != 'Full':
self.computeLocationsDifficulty(self.minorLocations, phase="minor")
# keep only the available locations
majorsAvailable = [loc for loc in self.majorLocations if loc.difficulty is not None and loc.difficulty.bool == True]
minorsAvailable = [loc for loc in self.minorLocations if loc.difficulty is not None and loc.difficulty.bool == True]
self.nbAvailLocs.append(len(self.getAllLocs(majorsAvailable, minorsAvailable)))
# remove next scavenger locs before checking if we're stuck
if self.majorsSplit == 'Scavenger':
majorsAvailable = self.filterScavengerLocs(majorsAvailable)
# check if we're stuck
if len(majorsAvailable) == 0 and len(minorsAvailable) == 0:
self.log.debug("STUCK MAJORS and MINORS")
if not self.endGameLoc.difficulty and self.canRelaxEnd():
self.log.debug("Can't collect 100% but Mother Brain is available in relax end")
majorsAvailable.append(self.endGameLoc)
elif self.comeBack.rewind(len(self.collectedItems)) == True:
self.log.debug("Rewind as we're stuck")
continue
else:
# we're really stucked
self.log.debug("STUCK CAN'T REWIND")
self.aborted = True
break
# handle no comeback locations
rewindRequired = self.comeBack.handleNoComeBack(majorsAvailable, minorsAvailable,
len(self.collectedItems))
if rewindRequired == True:
if self.comeBack.rewind(len(self.collectedItems)) == True:
continue
else:
# we're really stucked
self.log.debug("STUCK CAN'T REWIND")
self.aborted = True
break
# sort them on difficulty and proximity
self.log.debug("getAvailableItemsList majors")
majorsAvailable = self.getAvailableItemsList(majorsAvailable, diffThreshold)
if self.majorsSplit == 'Full':
minorsAvailable = majorsAvailable
else:
self.log.debug("getAvailableItemsList minors")
minorsAvailable = self.getAvailableItemsList(minorsAvailable, diffThreshold)
# choose one to pick up
hasEnoughMinors = self.pickup.enoughMinors(self.smbm, self.minorLocations)
self.nextDecision(majorsAvailable, minorsAvailable, hasEnoughMinors, diffThreshold)
self.comeBack.cleanNoComeBack(self.getAllLocs(self.majorLocations, self.minorLocations))
# compute difficulty value
(difficulty, itemsOk) = self.computeDifficultyValue()
if self.log.getEffectiveLevel() == logging.DEBUG:
self.log.debug("difficulty={}".format(difficulty))
self.log.debug("itemsOk={}".format(itemsOk))
self.log.debug("{}: remaining major: {}, remaining minor: {}, visited: {}".format(Conf.itemsPickup, len(self.majorLocations), len(self.minorLocations), len(self.visitedLocations)))
self.log.debug("remaining majors:")
for loc in self.majorLocations:
self.log.debug("{} ({})".format(loc.Name, loc.itemName))
self.log.debug("bosses: {}".format([(boss, Bosses.bossDead(self.smbm, boss)) for boss in Bosses.Golden4()]))
return (difficulty, itemsOk)
def haveAllMinorTypes(self):
# the first minor of each type can be seen as a major, so check for them first before going to far in zebes
hasPB = 'PowerBomb' in self.collectedItems
hasSuper = 'Super' in self.collectedItems
hasMissile = 'Missile' in self.collectedItems
return (hasPB and hasSuper and hasMissile)
def getAllLocs(self, majorsAvailable, minorsAvailable):
if self.majorsSplit == 'Full':
return majorsAvailable
else:
return majorsAvailable+minorsAvailable
def computeDifficultyValue(self):
if self.aborted:
# we have aborted
return (-1, False)
else:
# return the maximum difficulty
difficultyMax = 0
for loc in self.visitedLocations:
difficultyMax = max(difficultyMax, loc.difficulty.difficulty)
difficulty = difficultyMax
# check if we have taken all the requested items
if (self.pickup.enoughMinors(self.smbm, self.minorLocations)
and self.pickup.enoughMajors(self.smbm, self.majorLocations)):
return (difficulty, True)
else:
# can finish but can't take all the requested items
return (difficulty, False)
def getScavengerHuntState(self):
# check where we are in the scavenger hunt
huntInProgress = False
for index, loc in enumerate(self.scavengerOrder):
if loc not in self.visitedLocations:
huntInProgress = True
break
return (huntInProgress, index)
def filterScavengerLocs(self, majorsAvailable):
huntInProgress, index = self.getScavengerHuntState()
if huntInProgress and index < len(self.scavengerOrder)-1:
self.log.debug("Scavenger hunt in progress, {}/{}".format(index, len(self.scavengerOrder)-1))
# remove all next locs in the hunt
nextHuntLocs = self.scavengerOrder[index+1:]
for loc in nextHuntLocs:
self.log.debug("Scavenger hunt, try to remove loc {}".format(loc.Name))
try:
majorsAvailable.remove(loc)
except:
pass
return majorsAvailable
def scavengerHuntComplete(self, smbm=None, ap=None):
if self.masterMajorsSplit != 'Scavenger':
return SMBool(True)
else:
# check that last loc from the scavenger hunt list has been visited
lastLoc = self.scavengerOrder[-1]
return SMBool(lastLoc in self.visitedLocations)
def getPriorityArea(self):
# if scav returns solve area of next loc in the hunt
if self.majorsSplit != 'Scavenger':
return None
else:
huntInProgress, index = self.getScavengerHuntState()
if huntInProgress and index < len(self.scavengerOrder)-1:
return self.scavengerOrder[index].SolveArea
else:
return None
| {
"content_hash": "2b37010992bd1d3c356398b4973a25b6",
"timestamp": "",
"source": "github",
"line_count": 882,
"max_line_length": 202,
"avg_line_length": 47.39229024943311,
"alnum_prop": 0.5842822966507177,
"repo_name": "theonlydude/RandomMetroidSolver",
"id": "34f9140ce2bcb2c6f30a69f6107b4607ceb64ff8",
"size": "41800",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "solver/commonSolver.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Assembly",
"bytes": "323310"
},
{
"name": "CSS",
"bytes": "70414"
},
{
"name": "Dockerfile",
"bytes": "3915"
},
{
"name": "HTML",
"bytes": "916237"
},
{
"name": "JavaScript",
"bytes": "975366"
},
{
"name": "Lua",
"bytes": "2247"
},
{
"name": "Makefile",
"bytes": "3217"
},
{
"name": "Perl",
"bytes": "1680"
},
{
"name": "Python",
"bytes": "2240472"
},
{
"name": "Shell",
"bytes": "227851"
}
],
"symlink_target": ""
} |
"""A setuptools based setup module.
See:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
# Always prefer setuptools over distutils
import re
import os
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
def get_requires(filename):
requirements = []
with open(filename, 'rt') as req_file:
for line in req_file.read().splitlines():
if not line.strip().startswith("#"):
requirements.append(line)
return requirements
def load_version():
"""Loads a file content"""
filename = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),
"cpt", "__init__.py"))
with open(filename, "rt") as version_file:
conan_init = version_file.read()
version = re.search("__version__ = '([0-9a-z.-]+)'", conan_init).group(1)
return version
project_requirements = get_requires("cpt/requirements.txt")
setup(
name='conan_package_tools',
# Versions should comply with PEP440. For a discussion on single-sourcing
# the version across setup.py and the project code, see
# https://packaging.python.org/en/latest/single_source_version.html
version=load_version(),
description='Packaging tools for Conan C/C++ package manager',
# The project's main homepage.
url='https://github.com/conan-io/conan-package-tools',
# Author details
author='JFrog LTD. Luis Martinez de Bartolome',
author_email='[email protected]',
# Choose your license
license='MIT',
# See https://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'Topic :: Software Development :: Build Tools',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
],
# What does your project relate to?
keywords=['conan', 'C/C++', 'package', 'libraries', 'developer', 'manager',
'dependency', 'tool', 'c', 'c++', 'cpp'],
# You can just specify the packages manually here if your project is
# simple. Or you can use find_packages().
packages=find_packages(),
# Alternatively, if you want to distribute just a my_module.py, uncomment
# this:
# py_modules=["my_module"],
# List run-time dependencies here. These will be installed by pip when
# your project is installed. For an analysis of "install_requires" vs pip's
# requirements files see:
# https://packaging.python.org/en/latest/requirements.html
install_requires=project_requirements,
# List additional groups of dependencies here (e.g. development
# dependencies). You can install these using the following syntax,
# for example:
# $ pip install -e .[dev,test]
extras_require={
},
# If there are data files included in your packages that need to be
# installed, specify them here. If using Python 2.6 or less, then these
# have to be included in MANIFEST.in as well.
package_data={
'cpt': ['*.txt'],
},
# Although 'package_data' is the preferred approach, in some case you may
# need to place data files outside of your packages. See:
# http://docs.python.org/3.4/distutils/setupscript.html#installing-additional-files # noqa
# In this case, 'data_file' will be installed into '<sys.prefix>/my_data'
# data_files=[('my_data', ['data/data_file'])],
# To provide executable scripts, use entry points in preference to the
# "scripts" keyword. Entry points provide cross-platform support and allow
# pip to create the appropriate form of executable for the target platform.
entry_points={
'console_scripts': [
'run_create_in_docker=cpt.run_in_docker:run',
],
},
)
| {
"content_hash": "bc51844229cd0e3085397daf6799f321",
"timestamp": "",
"source": "github",
"line_count": 113,
"max_line_length": 94,
"avg_line_length": 35.36283185840708,
"alnum_prop": 0.6504004004004004,
"repo_name": "cstb/conan-package-tools",
"id": "74ce48c93da3749095d0121774c3b1e15963e3e8",
"size": "3996",
"binary": false,
"copies": "1",
"ref": "refs/heads/develop",
"path": "setup.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Batchfile",
"bytes": "289"
},
{
"name": "Python",
"bytes": "255403"
},
{
"name": "Shell",
"bytes": "1315"
}
],
"symlink_target": ""
} |
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "hermes.settings")
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
| {
"content_hash": "bcca9b79cf14bc1f879ae88cb8acda1c",
"timestamp": "",
"source": "github",
"line_count": 9,
"max_line_length": 70,
"avg_line_length": 25.22222222222222,
"alnum_prop": 0.7092511013215859,
"repo_name": "renanalencar/hermes",
"id": "7cf771168dd44a5266e11a98d049e2a60c256d52",
"size": "249",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "manage.py",
"mode": "33261",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "45248"
},
{
"name": "HTML",
"bytes": "48827"
},
{
"name": "JavaScript",
"bytes": "87491"
},
{
"name": "Python",
"bytes": "158986"
}
],
"symlink_target": ""
} |
import re
import traceback
class Interpreter:
def __init__(self):
self._inblock = False
self._last_empty = False
self._aggregate = []
self._environment = dict()
self.comments = re.compile(r'#.*$', re.MULTILINE)
self.identifier = re.compile(r'(?:^|\s)((?:[^\d\W]\w*\.)*(?:[^\d\W]\w*))$')
# blockopeners are :({[ and """,'''
# currently, we find them by explicitly looking for compilation errors
# TODO: find better way to do this
self.blockopeners = (
'EOF while scanning triple-quoted string literal',
'unexpected EOF while parsing'
)
def inblock(self):
"""
Returns whether a block is open currently.
:return: True if a block is open
"""
return self._inblock
def eval(self, line):
"""
Evaluates line, looks for blocks and eventually executes statements...
:param line: Line to be fed
:return:
"""
stripped_line = self._strip(line)
if len(stripped_line) == 0:
# leave block if:
# - line completely empty
# - or two empty tab lines
if self._inblock:
only_spaces = len(line.strip()) == 0
# if block is left, execute aggregation
# leave if line empty or last empty and only spaces
if len(line) == 0 or (self._last_empty and only_spaces):
code = '\n'.join(self._aggregate)
compilation = self._try_compile(code)
if compilation is False:
return
self._aggregate = []
self._inblock = False
self._last_empty = False
self._exec(compilation)
elif only_spaces:
# only spaces, so we need two such lines
self._last_empty = True
else:
self._last_empty = False
return # if empty line
if not self._inblock:
compilation = self._try_compile(line)
self._last_empty = False
if self._inblock:
self._aggregate.append(line)
else:
self._exec(compilation)
def _try_compile(self, line):
try:
return compile(line, '<input>', 'single')
except SyntaxError as e:
if e.msg in self.blockopeners:
self._inblock = True
else:
traceback.print_exc()
except Exception as e:
traceback.print_exc()
return False
def _exec(self, compilation):
"""
Executes some code and catches exceptions.
:param code: Code to execute
:return:
"""
try:
exec(compilation, self._environment)
except Exception as e:
traceback.print_exc()
def _strip(self, line):
"""
Strips away comments and spaces.
:param line: The line to strip
:return: The stripped line
"""
return self.comments.sub('', line).strip()
def complete(self, line):
"""
A preliminary auto complete function.
Only works for things in the global environment, so far!
And only up to a depth of 1.
:param line: the current line
:return: completion in case of success, False otherwise
"""
match = self.identifier.search(line)
if match is not None:
parts = match.group(1).split('.')
environ = self._environment
if len(parts) > 0:
last_part = parts[-1]
# submodules
if len(parts) > 1:
if parts[-2] not in environ:
return False
environ = dir(environ[parts[-2]]) # update environ
matches = [key for key in environ if key.startswith(last_part)]
if len(matches) == 1:
return matches[0][len(last_part):]
return False | {
"content_hash": "3a29324e18d15a1e04b5885b82b5c075",
"timestamp": "",
"source": "github",
"line_count": 126,
"max_line_length": 83,
"avg_line_length": 32.74603174603175,
"alnum_prop": 0.5053320407174018,
"repo_name": "paberr/ppython",
"id": "2c0c863fde781b1e6c251cc3e564435a95a975a2",
"size": "4126",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "ppython/interpreter.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "19424"
}
],
"symlink_target": ""
} |
import os
import random
import logging
import stat
_logger = logging.getLogger("cwltool")
def abspath(src, basedir):
if src.startswith("file://"):
ab = src[7:]
else:
ab = src if os.path.isabs(src) else os.path.join(basedir, src)
return ab
class PathMapper(object):
"""Mapping of files from relative path provided in the file to a tuple of
(absolute local path, absolute container path)"""
def __init__(self, referenced_files, basedir):
self._pathmap = {}
for src in referenced_files:
ab = abspath(src, basedir)
self._pathmap[src] = (ab, ab)
def mapper(self, src):
return self._pathmap[src]
def files(self):
return self._pathmap.keys()
def reversemap(self, target):
for k,v in self._pathmap.items():
if v[1] == target:
return (k, v[0])
class DockerPathMapper(PathMapper):
def __init__(self, referenced_files, basedir):
self._pathmap = {}
self.dirs = {}
for src in referenced_files:
ab = abspath(src, basedir)
dir, fn = os.path.split(ab)
subdir = False
for d in self.dirs:
if dir.startswith(d):
subdir = True
break
if not subdir:
for d in list(self.dirs):
if d.startswith(dir):
# 'dir' is a parent of 'd'
del self.dirs[d]
self.dirs[dir] = True
prefix = "job" + str(random.randint(1, 1000000000)) + "_"
names = set()
for d in self.dirs:
name = os.path.join("/tmp", prefix + os.path.basename(d))
i = 1
while name in names:
i += 1
name = os.path.join("/tmp", prefix + os.path.basename(d) + str(i))
names.add(name)
self.dirs[d] = name
for src in referenced_files:
ab = abspath(src, basedir)
deref = ab
st = os.lstat(deref)
while stat.S_ISLNK(st.st_mode):
rl = os.readlink(deref)
deref = rl if os.path.isabs(rl) else os.path.join(os.path.dirname(deref), rl)
st = os.lstat(deref)
for d in self.dirs:
if ab.startswith(d):
self._pathmap[src] = (deref, os.path.join(self.dirs[d], ab[len(d)+1:]))
| {
"content_hash": "ea8368f8b7faff8cd71a579cbdfd880f",
"timestamp": "",
"source": "github",
"line_count": 80,
"max_line_length": 93,
"avg_line_length": 30.6375,
"alnum_prop": 0.507547939616483,
"repo_name": "brainstorm/common-workflow-language",
"id": "ef739cf85d3a615bad5b3f982e2e35d655698e8b",
"size": "2451",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "reference/cwltool/pathmapper.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "JavaScript",
"bytes": "96185"
},
{
"name": "Python",
"bytes": "97848"
},
{
"name": "Shell",
"bytes": "5941"
}
],
"symlink_target": ""
} |
import random
import numpy
from matplotlib import pyplot ## == import matplotlib.pyplot
## Hive + Enemy
num_bees = 1000
num_warrior =numpy.random.randint(1,num_bees+1)
num_worker= num_bees - num_warrior
alert=False
print "num warrior", num_warrior
print "num worker", num_worker
print "\n"
class Queen_Bee:
hp=1000
dead = False
nutrition=0
def make_bees(self,worker_bee, warrior_bee):
while self.nutrition>0:
if alert==True:
warrior_bee.append(Warrior_Bee())
self.nutrition=self.nutrition-1
else:
worker_bee.append(Worker_Bee())
self.nutrition=self.nutrition-1
#warrior_bee, worker_bee's hp==1
class Warrior_Bee:
at=2
dead = False
def attack(self,enemy):
enemy.hp=enemy.hp-self.at
class Worker_Bee:
dead = False
def work(self, queen):
queen.nutrition=queen.nutrition+1
class Enemy:
hp=10000
at=400
dead = False
def attack(self, worker_bee, warrior_bee, queen):
if len(warrior_bee)>=self.at:
del warrior_bee[0:self.at]
elif self.at<=len(warrior_bee)+len(worker_bee) and len(warrior_bee)<self.at:
del worker_bee[0:self.at-len(warrior_bee)]
del warrior_bee[:]
elif self.at>len(warrior_bee)+len(worker_bee):
queen.hp=queen.hp-self.at+len(warrior_bee)+len(worker_bee)
del warrior_bee[:]
del worker_bee[:]
## Bee, Enemy »ý¼º
queen=Queen_Bee()
warrior_bee=[]
worker_bee=[]
for index in range(0, num_warrior):
bee=Warrior_Bee()
warrior_bee.append(bee)
for index in range(0, num_worker):
bee=Worker_Bee()
worker_bee.append(bee)
enemy = Enemy()
## Fight
steps= []
enemy_hps = []
queen_hps=[]
num_worker=[]
num_warrior=[]
step = 0
while enemy.hp>0 and queen.hp>0:
for worker in worker_bee:
worker.work(queen)
print "nutrition before ¾Ë", queen.nutrition
for warrior in warrior_bee:
warrior.attack(enemy)
new_warrior_bee=[]
for warrior in warrior_bee:
if warrior.dead==False:
new_warrior_bee.append(warrior)
warrior_bee=new_warrior_bee
print "enemy hp", enemy.hp
print "num warrior", len(warrior_bee)
print "num worker", len(worker_bee)
enemy.attack(worker_bee, warrior_bee, queen)
print "num warrior", len(warrior_bee)
print "num worker", len(worker_bee)
print "qeen hp", queen.hp
if len(warrior_bee)<=0:
alert=True
else:
alert=False
print "alert", alert
queen.make_bees(worker_bee, warrior_bee)
print "nutrition after ¾Ë", queen.nutrition
print "num warrior", len(warrior_bee)
print "num worker", len(worker_bee), "\n"
step=step+1
steps.append(step)
enemy_hps.append(enemy.hp)
queen_hps.append(queen.hp)
num_worker.append(len(worker_bee))
num_warrior.append(len(warrior_bee))
if enemy.hp<0:
print "bees win"
elif queen.hp<0:
print "enemy wins"
# print steps, "\n", enemy_hps, "\n" , queen_hps, "\n" , num_worker, "\n", num_warrior
pyplot.plot(steps, enemy_hps, label="enemy_hps")
pyplot.plot(steps, queen_hps, label="queen_hps")
pyplot.plot(steps, num_worker, label="# of worker bee")
pyplot.plot(steps, num_warrior, label="# of warrior bee")
pyplot.legend()
pyplot.show()
| {
"content_hash": "565b62a60ca9d4b182b2512480da3a17",
"timestamp": "",
"source": "github",
"line_count": 170,
"max_line_length": 89,
"avg_line_length": 20.347058823529412,
"alnum_prop": 0.6082682856316854,
"repo_name": "omsktransmash/ScientificPythonTutorial",
"id": "7566cf85d72e67ba7994350523f5da633b293cc9",
"size": "3459",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "Hyeokkoo/0701 (bee HW).py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Python",
"bytes": "84355"
}
],
"symlink_target": ""
} |
from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
unicode_literals, with_statement)
import logging
import sys
import lockfile
import psutil
from lockfile import pidlockfile
logger = logging.getLogger(__name__)
class OwnerPrintingPIDLockFile(pidlockfile.PIDLockFile):
def acquire(self, timeout=None):
# If the lock is held, attempt to determine holder and print a message before waiting.
# If owner process cannot be found, go ahead and kill the orphaned lock file before waiting.
if self.is_locked():
try:
pid = self.read_pid()
cmd = self.cmdline_for_pid(pid)
if cmd is not None:
print('Waiting on pants process {0} ({1}) to complete'.format(pid, cmd), file=sys.stderr)
else:
self.break_lock()
except Exception as e:
logger.warn('Error while determining lock owner: {0}'.format(e))
return pidlockfile.PIDLockFile.acquire(self, timeout)
@staticmethod
def cmdline_for_pid(pid):
try:
process = psutil.Process(pid)
return ' '.join(process.cmdline)
except psutil.NoSuchProcess:
return None
| {
"content_hash": "526abffa7ac515cfd73343bfd68f7afb",
"timestamp": "",
"source": "github",
"line_count": 37,
"max_line_length": 99,
"avg_line_length": 31.89189189189189,
"alnum_prop": 0.6754237288135593,
"repo_name": "tejal29/pants",
"id": "2f7780dc51a1834ee64e407b01bc94147a3186a0",
"size": "1327",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "src/python/pants/process/pidlock.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "CSS",
"bytes": "10977"
},
{
"name": "GAP",
"bytes": "4810"
},
{
"name": "HTML",
"bytes": "75563"
},
{
"name": "Java",
"bytes": "47798"
},
{
"name": "JavaScript",
"bytes": "10157"
},
{
"name": "Protocol Buffer",
"bytes": "5348"
},
{
"name": "Python",
"bytes": "2364916"
},
{
"name": "Scala",
"bytes": "5556"
},
{
"name": "Shell",
"bytes": "39930"
},
{
"name": "Thrift",
"bytes": "1841"
},
{
"name": "XML",
"bytes": "8658"
}
],
"symlink_target": ""
} |
"""
Test the parallel module.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2010-2011 Gael Varoquaux
# License: BSD Style, 3 clauses.
import time
try:
import cPickle as pickle
PickleError = TypeError
except:
import pickle
PickleError = pickle.PicklingError
from ..parallel import Parallel, delayed, SafeFunction, WorkerInterrupt, \
multiprocessing, cpu_count
from ..my_exceptions import JoblibException
import nose
################################################################################
def division(x, y):
return x/y
def square(x):
return x**2
def exception_raiser(x):
if x == 7:
raise ValueError
return x
def interrupt_raiser(x):
time.sleep(.05)
raise KeyboardInterrupt
def f(x, y=0, z=0):
""" A module-level function so that it can be spawn with
multiprocessing.
"""
return x**2 + y + z
################################################################################
def test_cpu_count():
assert cpu_count() > 0
################################################################################
# Test parallel
def test_simple_parallel():
X = range(10)
for n_jobs in (1, 2, -1):
yield (nose.tools.assert_equal, [square(x) for x in X],
Parallel(n_jobs=-1)(delayed(square)(x) for x in X))
def test_parallel_kwargs():
""" Check the keyword argument processing of pmap.
"""
lst = range(10)
for n_jobs in (1, 4):
yield (nose.tools.assert_equal,
[f(x, y=1) for x in lst],
Parallel(n_jobs=n_jobs)(delayed(f)(x, y=1) for x in lst)
)
def test_parallel_pickling():
""" Check that pmap captures the errors when it is passed an object
that cannot be pickled.
"""
def g(x):
return x**2
nose.tools.assert_raises(PickleError,
Parallel(),
(delayed(g)(x) for x in range(10))
)
def test_error_capture():
""" Check that error are captured, and that correct exceptions
are raised.
"""
if multiprocessing is not None:
# A JoblibException will be raised only if there is indeed
# multiprocessing
nose.tools.assert_raises(JoblibException,
Parallel(n_jobs=2),
[delayed(division)(x, y) for x, y in zip((0, 1), (1, 0))],
)
nose.tools.assert_raises(WorkerInterrupt,
Parallel(n_jobs=2),
[delayed(interrupt_raiser)(x) for x in (1, 0)],
)
else:
nose.tools.assert_raises(KeyboardInterrupt,
Parallel(n_jobs=2),
[delayed(interrupt_raiser)(x) for x in (1, 0)],
)
nose.tools.assert_raises(ZeroDivisionError,
Parallel(n_jobs=2),
[delayed(division)(x, y) for x, y in zip((0, 1), (1, 0))],
)
try:
Parallel(n_jobs=1)(
delayed(division)(x, y) for x, y in zip((0, 1), (1, 0)))
except Exception, e:
pass
nose.tools.assert_false(isinstance(e, JoblibException))
class Counter(object):
def __init__(self, list1, list2):
self.list1 = list1
self.list2 = list2
def __call__(self, i):
self.list1.append(i)
nose.tools.assert_equal(len(self.list1), len(self.list2))
def consumer(queue, item):
queue.append('Consumed %s' % item)
def test_dispatch_one_job():
""" Test that with only one job, Parallel does act as a iterator.
"""
queue = list()
def producer():
for i in range(6):
queue.append('Produced %i' % i)
yield i
Parallel(n_jobs=1)(delayed(consumer)(queue, x) for x in producer())
nose.tools.assert_equal(queue,
['Produced 0', 'Consumed 0',
'Produced 1', 'Consumed 1',
'Produced 2', 'Consumed 2',
'Produced 3', 'Consumed 3',
'Produced 4', 'Consumed 4',
'Produced 5', 'Consumed 5']
)
nose.tools.assert_equal(len(queue), 12)
def test_dispatch_multiprocessing():
""" Check that using pre_dispatch Parallel does indeed dispatch items
lazily.
"""
if multiprocessing is None:
return
manager = multiprocessing.Manager()
queue = manager.list()
def producer():
for i in range(6):
queue.append('Produced %i' % i)
yield i
Parallel(n_jobs=2, pre_dispatch=3)(delayed(consumer)(queue, i)
for i in producer())
nose.tools.assert_equal(list(queue)[:4],
['Produced 0', 'Produced 1', 'Produced 2',
'Consumed 0', ])
nose.tools.assert_equal(len(queue), 12)
def test_exception_dispatch():
"Make sure that exception raised during dispatch are indeed captured"
nose.tools.assert_raises(
ValueError,
Parallel(n_jobs=6, pre_dispatch=16, verbose=0),
(delayed(exception_raiser)(i) for i in range(30)),
)
################################################################################
# Test helpers
def test_joblib_exception():
# Smoke-test the custom exception
e = JoblibException('foobar')
# Test the repr
repr(e)
# Test the pickle
pickle.dumps(e)
def test_safe_function():
safe_division = SafeFunction(division)
nose.tools.assert_raises(JoblibException, safe_division, 1, 0)
| {
"content_hash": "3cb2dbeae44b1d828630694525b405ee",
"timestamp": "",
"source": "github",
"line_count": 193,
"max_line_length": 80,
"avg_line_length": 30.067357512953368,
"alnum_prop": 0.5121488885059452,
"repo_name": "ominux/scikit-learn",
"id": "2599acb393439c3a178716305fcaa0591e02449e",
"size": "5803",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "sklearn/externals/joblib/test/test_parallel.py",
"mode": "33261",
"license": "bsd-3-clause",
"language": [
{
"name": "C",
"bytes": "455969"
},
{
"name": "C++",
"bytes": "240380"
},
{
"name": "Makefile",
"bytes": "1411"
},
{
"name": "Python",
"bytes": "2064853"
},
{
"name": "Shell",
"bytes": "486"
}
],
"symlink_target": ""
} |
import time
from oslo_log import log as logging
from oslo_service import loopingcall
from cinder import coordination
from cinder import exception
from cinder.i18n import _
from cinder.volume.drivers.dell_emc.vmax import utils
LOG = logging.getLogger(__name__)
WRITE_DISABLED = "Write Disabled"
UNLINK_INTERVAL = 15
UNLINK_RETRIES = 30
class VMAXProvision(object):
"""Provisioning Class for Dell EMC VMAX volume drivers.
It supports VMAX arrays.
"""
def __init__(self, rest):
self.utils = utils.VMAXUtils()
self.rest = rest
def create_storage_group(
self, array, storagegroup_name, srp, slo, workload,
extra_specs, do_disable_compression=False):
"""Create a new storage group.
:param array: the array serial number
:param storagegroup_name: the group name (String)
:param srp: the SRP (String)
:param slo: the SLO (String)
:param workload: the workload (String)
:param extra_specs: additional info
:param do_disable_compression: disable compression flag
:returns: storagegroup - storage group object
"""
start_time = time.time()
@coordination.synchronized("emc-sg-{storage_group}")
def do_create_storage_group(storage_group):
# Check if storage group has been recently created
storagegroup = self.rest.get_storage_group(
array, storagegroup_name)
if storagegroup is None:
storagegroup = self.rest.create_storage_group(
array, storage_group, srp, slo, workload, extra_specs,
do_disable_compression)
LOG.debug("Create storage group took: %(delta)s H:MM:SS.",
{'delta': self.utils.get_time_delta(start_time,
time.time())})
LOG.info("Storage group %(sg)s created successfully.",
{'sg': storagegroup_name})
else:
LOG.info("Storage group %(sg)s already exists.",
{'sg': storagegroup_name})
return storagegroup
return do_create_storage_group(storagegroup_name)
def create_volume_from_sg(self, array, volume_name, storagegroup_name,
volume_size, extra_specs):
"""Create a new volume in the given storage group.
:param array: the array serial number
:param volume_name: the volume name (String)
:param storagegroup_name: the storage group name
:param volume_size: volume size (String)
:param extra_specs: the extra specifications
:returns: dict -- volume_dict - the volume dict
"""
@coordination.synchronized("emc-sg-{storage_group}")
def do_create_volume_from_sg(storage_group):
start_time = time.time()
volume_dict = self.rest.create_volume_from_sg(
array, volume_name, storage_group,
volume_size, extra_specs)
LOG.debug("Create volume from storage group "
"took: %(delta)s H:MM:SS.",
{'delta': self.utils.get_time_delta(start_time,
time.time())})
return volume_dict
return do_create_volume_from_sg(storagegroup_name)
def delete_volume_from_srp(self, array, device_id, volume_name):
"""Delete a volume from the srp.
:param array: the array serial number
:param device_id: the volume device id
:param volume_name: the volume name
"""
start_time = time.time()
LOG.debug("Delete volume %(volume_name)s from srp.",
{'volume_name': volume_name})
self.rest.delete_volume(array, device_id)
LOG.debug("Delete volume took: %(delta)s H:MM:SS.",
{'delta': self.utils.get_time_delta(
start_time, time.time())})
def create_volume_snapvx(self, array, source_device_id,
snap_name, extra_specs):
"""Create a snapVx of a volume.
:param array: the array serial number
:param source_device_id: source volume device id
:param snap_name: the snapshot name
:param extra_specs: the extra specifications
"""
start_time = time.time()
LOG.debug("Create Snap Vx snapshot of: %(source)s.",
{'source': source_device_id})
self.rest.create_volume_snap(
array, snap_name, source_device_id, extra_specs)
LOG.debug("Create volume snapVx took: %(delta)s H:MM:SS.",
{'delta': self.utils.get_time_delta(start_time,
time.time())})
def create_volume_replica(
self, array, source_device_id, target_device_id,
snap_name, extra_specs, create_snap=False):
"""Create a snap vx of a source and copy to a target.
:param array: the array serial number
:param source_device_id: source volume device id
:param target_device_id: target volume device id
:param snap_name: the name for the snap shot
:param extra_specs: extra specifications
:param create_snap: Flag for create snapvx
"""
start_time = time.time()
if create_snap:
self.create_volume_snapvx(array, source_device_id,
snap_name, extra_specs)
# Link source to target
self.rest.modify_volume_snap(
array, source_device_id, target_device_id, snap_name,
extra_specs, link=True)
LOG.debug("Create element replica took: %(delta)s H:MM:SS.",
{'delta': self.utils.get_time_delta(start_time,
time.time())})
def break_replication_relationship(
self, array, target_device_id, source_device_id, snap_name,
extra_specs):
"""Unlink a snapshot from its target volume.
:param array: the array serial number
:param source_device_id: source volume device id
:param target_device_id: target volume device id
:param snap_name: the name for the snap shot
:param extra_specs: extra specifications
"""
LOG.debug("Break snap vx link relationship between: %(src)s "
"and: %(tgt)s.",
{'src': source_device_id, 'tgt': target_device_id})
self._unlink_volume(array, source_device_id, target_device_id,
snap_name, extra_specs)
def _unlink_volume(
self, array, source_device_id, target_device_id, snap_name,
extra_specs, list_volume_pairs=None):
"""Unlink a target volume from its source volume.
:param array: the array serial number
:param source_device_id: the source device id
:param target_device_id: the target device id
:param snap_name: the snap name
:param extra_specs: extra specifications
:param list_volume_pairs: list of volume pairs, optional
:return: return code
"""
def _unlink_vol():
"""Called at an interval until the synchronization is finished.
:raises: loopingcall.LoopingCallDone
"""
retries = kwargs['retries']
try:
kwargs['retries'] = retries + 1
if not kwargs['modify_vol_success']:
self.rest.modify_volume_snap(
array, source_device_id, target_device_id, snap_name,
extra_specs, unlink=True,
list_volume_pairs=list_volume_pairs)
kwargs['modify_vol_success'] = True
except exception.VolumeBackendAPIException:
pass
if kwargs['retries'] > UNLINK_RETRIES:
LOG.error("_unlink_volume failed after %(retries)d "
"tries.", {'retries': retries})
raise loopingcall.LoopingCallDone(retvalue=30)
if kwargs['modify_vol_success']:
raise loopingcall.LoopingCallDone()
kwargs = {'retries': 0,
'modify_vol_success': False}
timer = loopingcall.FixedIntervalLoopingCall(_unlink_vol)
rc = timer.start(interval=UNLINK_INTERVAL).wait()
return rc
def delete_volume_snap(self, array, snap_name,
source_device_id, restored=False):
"""Delete a snapVx snapshot of a volume.
:param array: the array serial number
:param snap_name: the snapshot name
:param source_device_id: the source device id
:param restored: Flag to indicate if restored session is being deleted
"""
LOG.debug("Delete SnapVx: %(snap_name)s for volume %(vol)s.",
{'vol': source_device_id, 'snap_name': snap_name})
self.rest.delete_volume_snap(
array, snap_name, source_device_id, restored)
def is_restore_complete(self, array, source_device_id,
snap_name, extra_specs):
"""Check and wait for a restore to complete
:param array: the array serial number
:param source_device_id: source device id
:param snap_name: snapshot name
:param extra_specs: extra specification
:returns: bool
"""
def _wait_for_restore():
"""Called at an interval until the restore is finished.
:raises: loopingcall.LoopingCallDone
:raises: VolumeBackendAPIException
"""
retries = kwargs['retries']
try:
kwargs['retries'] = retries + 1
if not kwargs['wait_for_restore_called']:
if self._is_restore_complete(
array, source_device_id, snap_name):
kwargs['wait_for_restore_called'] = True
except Exception:
exception_message = (_("Issue encountered waiting for "
"restore."))
LOG.exception(exception_message)
raise exception.VolumeBackendAPIException(
data=exception_message)
if kwargs['wait_for_restore_called']:
raise loopingcall.LoopingCallDone()
if kwargs['retries'] > int(extra_specs[utils.RETRIES]):
LOG.error("_wait_for_restore failed after %(retries)d "
"tries.", {'retries': retries})
raise loopingcall.LoopingCallDone(
retvalue=int(extra_specs[utils.RETRIES]))
kwargs = {'retries': 0,
'wait_for_restore_called': False}
timer = loopingcall.FixedIntervalLoopingCall(_wait_for_restore)
rc = timer.start(interval=int(extra_specs[utils.INTERVAL])).wait()
return rc
def _is_restore_complete(self, array, source_device_id, snap_name):
"""Helper function to check if restore is complete.
:param array: the array serial number
:param source_device_id: source device id
:param snap_name: the snapshot name
:returns: restored -- bool
"""
restored = False
snap_details = self.rest.get_volume_snap(
array, source_device_id, snap_name)
if snap_details:
linked_devices = snap_details.get("linkedDevices", [])
for linked_device in linked_devices:
if ('targetDevice' in linked_device and
source_device_id == linked_device['targetDevice']):
if ('state' in linked_device and
linked_device['state'] == "Restored"):
restored = True
return restored
def delete_temp_volume_snap(self, array, snap_name, source_device_id):
"""Delete the temporary snapshot created for clone operations.
There can be instances where the source and target both attempt to
delete a temp snapshot simultaneously, so we must lock the snap and
then double check it is on the array.
:param array: the array serial number
:param snap_name: the snapshot name
:param source_device_id: the source device id
"""
@coordination.synchronized("emc-snapvx-{snapvx_name}")
def do_delete_temp_snap(snapvx_name):
# Ensure snap has not been recently deleted
if self.rest.get_volume_snap(
array, source_device_id, snapvx_name):
self.delete_volume_snap(array, snapvx_name, source_device_id)
do_delete_temp_snap(snap_name)
def delete_volume_snap_check_for_links(self, array, snap_name,
source_devices, extra_specs):
"""Check if a snap has any links before deletion.
If a snapshot has any links, break the replication relationship
before deletion.
:param array: the array serial number
:param snap_name: the snapshot name
:param source_devices: the source device ids
:param extra_specs: the extra specifications
"""
list_device_pairs = []
if not isinstance(source_devices, list):
source_devices = [source_devices]
for source_device in source_devices:
LOG.debug("Check for linked devices to SnapVx: %(snap_name)s "
"for volume %(vol)s.",
{'vol': source_device, 'snap_name': snap_name})
linked_list = self.rest.get_snap_linked_device_list(
array, source_device, snap_name)
for link in linked_list:
target_device = link['targetDevice']
list_device_pairs.append((source_device, target_device))
if list_device_pairs:
self._unlink_volume(array, "", "", snap_name, extra_specs,
list_volume_pairs=list_device_pairs)
self.delete_volume_snap(array, snap_name, source_devices)
def extend_volume(self, array, device_id, new_size, extra_specs,
rdf_group=None):
"""Extend a volume.
:param array: the array serial number
:param device_id: the volume device id
:param new_size: the new size (GB)
:param extra_specs: the extra specifications
:param rdf_group: the rdf group number, if required
:returns: status_code
"""
start_time = time.time()
if rdf_group:
@coordination.synchronized('emc-rg-{rdf_group}')
def _extend_replicated_volume(rdf_group):
self.rest.extend_volume(array, device_id,
new_size, extra_specs)
_extend_replicated_volume(rdf_group)
else:
self.rest.extend_volume(array, device_id, new_size, extra_specs)
LOG.debug("Extend VMAX volume took: %(delta)s H:MM:SS.",
{'delta': self.utils.get_time_delta(start_time,
time.time())})
def get_srp_pool_stats(self, array, array_info):
"""Get the srp capacity stats.
:param array: the array serial number
:param array_info: the array dict
:returns: total_capacity_gb
:returns: remaining_capacity_gb
:returns: subscribed_capacity_gb
:returns: array_reserve_percent
"""
total_capacity_gb = 0
remaining_capacity_gb = 0
subscribed_capacity_gb = 0
array_reserve_percent = 0
srp = array_info['srpName']
LOG.debug(
"Retrieving capacity for srp %(srpName)s on array %(array)s.",
{'srpName': srp, 'array': array})
srp_details = self.rest.get_srp_by_name(array, srp)
if not srp_details:
LOG.error("Unable to retrieve srp instance of %(srpName)s on "
"array %(array)s.",
{'srpName': srp, 'array': array})
return 0, 0, 0, 0, False
try:
total_capacity_gb = srp_details['total_usable_cap_gb']
try:
used_capacity_gb = srp_details['total_used_cap_gb']
remaining_capacity_gb = float(
total_capacity_gb - used_capacity_gb)
except KeyError:
remaining_capacity_gb = srp_details['fba_free_capacity']
subscribed_capacity_gb = srp_details['total_subscribed_cap_gb']
array_reserve_percent = srp_details['reserved_cap_percent']
except KeyError:
pass
return (total_capacity_gb, remaining_capacity_gb,
subscribed_capacity_gb, array_reserve_percent)
def verify_slo_workload(self, array, slo, workload, srp):
"""Check if SLO and workload values are valid.
:param array: the array serial number
:param slo: Service Level Object e.g bronze
:param workload: workload e.g DSS
:param srp: the storage resource pool name
:returns: boolean
"""
is_valid_slo, is_valid_workload = False, False
if workload and workload.lower() == 'none':
workload = None
if not workload:
is_valid_workload = True
if slo and slo.lower() == 'none':
slo = None
valid_slos = self.rest.get_slo_list(array)
valid_workloads = self.rest.get_workload_settings(array)
for valid_slo in valid_slos:
if slo == valid_slo:
is_valid_slo = True
break
for valid_workload in valid_workloads:
if workload == valid_workload:
is_valid_workload = True
break
if not slo:
is_valid_slo = True
if workload:
is_valid_workload = False
if not is_valid_slo:
LOG.error(
"SLO: %(slo)s is not valid. Valid values are: "
"%(valid_slos)s.", {'slo': slo, 'valid_slos': valid_slos})
if not is_valid_workload:
LOG.error(
"Workload: %(workload)s is not valid. Valid values are "
"%(valid_workloads)s. Note you cannot "
"set a workload without an SLO.",
{'workload': workload, 'valid_workloads': valid_workloads})
return is_valid_slo, is_valid_workload
def get_slo_workload_settings_from_storage_group(
self, array, sg_name):
"""Get slo and workload settings from a storage group.
:param array: the array serial number
:param sg_name: the storage group name
:returns: storage group slo settings
"""
slo = 'NONE'
workload = 'NONE'
storage_group = self.rest.get_storage_group(array, sg_name)
if storage_group:
try:
slo = storage_group['slo']
workload = storage_group['workload']
except KeyError:
pass
else:
exception_message = (_(
"Could not retrieve storage group %(sg_name)s. ") %
{'sg_name': sg_name})
LOG.error(exception_message)
raise exception.VolumeBackendAPIException(data=exception_message)
return '%(slo)s+%(workload)s' % {'slo': slo, 'workload': workload}
@coordination.synchronized('emc-rg-{rdf_group}')
def break_rdf_relationship(self, array, device_id, target_device,
rdf_group, rep_extra_specs, state):
"""Break the rdf relationship between a pair of devices.
:param array: the array serial number
:param device_id: the source device id
:param target_device: target device id
:param rdf_group: the rdf group number
:param rep_extra_specs: replication extra specs
:param state: the state of the rdf pair
"""
LOG.info("Suspending rdf pair: source device: %(src)s "
"target device: %(tgt)s.",
{'src': device_id, 'tgt': target_device})
if state.lower() == utils.RDF_SYNCINPROG_STATE:
self.rest.wait_for_rdf_consistent_state(
array, device_id, target_device,
rep_extra_specs, state)
if state.lower() == utils.RDF_SUSPENDED_STATE:
LOG.info("RDF pair is already suspended")
else:
self.rest.modify_rdf_device_pair(
array, device_id, rdf_group, rep_extra_specs, suspend=True)
self.delete_rdf_pair(array, device_id, rdf_group,
target_device, rep_extra_specs)
def break_metro_rdf_pair(self, array, device_id, target_device,
rdf_group, rep_extra_specs, metro_grp):
"""Delete replication for a Metro device pair.
Need to suspend the entire group before we can delete a single pair.
:param array: the array serial number
:param device_id: the device id
:param target_device: the target device id
:param rdf_group: the rdf group number
:param rep_extra_specs: the replication extra specifications
:param metro_grp: the metro storage group name
"""
# Suspend I/O on the RDF links...
LOG.info("Suspending I/O for all volumes in the RDF group: %(rdfg)s",
{'rdfg': rdf_group})
self.disable_group_replication(
array, metro_grp, rdf_group, rep_extra_specs)
self.delete_rdf_pair(array, device_id, rdf_group,
target_device, rep_extra_specs)
def delete_rdf_pair(
self, array, device_id, rdf_group, target_device, extra_specs):
"""Delete an rdf pairing.
If the replication mode is synchronous, only one attempt is required
to delete the pair. Otherwise, we need to wait until all the tracks
are cleared before the delete will be successful. As there is
currently no way to track this information, we keep attempting the
operation until it is successful.
:param array: the array serial number
:param device_id: source volume device id
:param rdf_group: the rdf group number
:param target_device: the target device
:param extra_specs: extra specifications
"""
LOG.info("Deleting rdf pair: source device: %(src)s "
"target device: %(tgt)s.",
{'src': device_id, 'tgt': target_device})
if (extra_specs.get(utils.REP_MODE) and
extra_specs.get(utils.REP_MODE) == utils.REP_SYNC):
return self.rest.delete_rdf_pair(array, device_id, rdf_group)
def _delete_pair():
"""Delete a rdf volume pair.
Called at an interval until all the tracks are cleared
and the operation is successful.
:raises: loopingcall.LoopingCallDone
"""
retries = kwargs['retries']
try:
kwargs['retries'] = retries + 1
if not kwargs['delete_pair_success']:
self.rest.delete_rdf_pair(
array, device_id, rdf_group)
kwargs['delete_pair_success'] = True
except exception.VolumeBackendAPIException:
pass
if kwargs['retries'] > UNLINK_RETRIES:
LOG.error("Delete volume pair failed after %(retries)d "
"tries.", {'retries': retries})
raise loopingcall.LoopingCallDone(retvalue=30)
if kwargs['delete_pair_success']:
raise loopingcall.LoopingCallDone()
kwargs = {'retries': 0,
'delete_pair_success': False}
timer = loopingcall.FixedIntervalLoopingCall(_delete_pair)
rc = timer.start(interval=UNLINK_INTERVAL).wait()
return rc
def get_or_create_volume_group(self, array, group, extra_specs):
"""Get or create a volume group.
Sometimes it may be necessary to recreate a volume group on the
backend - for example, when the last member volume has been removed
from the group, but the cinder group object has not been deleted.
:param array: the array serial number
:param group: the group object
:param extra_specs: the extra specifications
:return: group name
"""
vol_grp_name = self.utils.update_volume_group_name(group)
return self.get_or_create_group(array, vol_grp_name, extra_specs)
def get_or_create_group(self, array, group_name, extra_specs):
"""Get or create a generic volume group.
:param array: the array serial number
:param group_name: the group name
:param extra_specs: the extra specifications
:return: group name
"""
storage_group = self.rest.get_storage_group(array, group_name)
if not storage_group:
self.create_volume_group(array, group_name, extra_specs)
return group_name
def create_volume_group(self, array, group_name, extra_specs):
"""Create a generic volume group.
:param array: the array serial number
:param group_name: the name of the group
:param extra_specs: the extra specifications
:returns: volume_group
"""
return self.create_storage_group(array, group_name,
None, None, None, extra_specs)
def create_group_replica(
self, array, source_group, snap_name, extra_specs):
"""Create a replica (snapVx) of a volume group.
:param array: the array serial number
:param source_group: the source group name
:param snap_name: the name for the snap shot
:param extra_specs: extra specifications
"""
LOG.debug("Creating Snap Vx snapshot of storage group: %(srcGroup)s.",
{'srcGroup': source_group})
# Create snapshot
self.rest.create_storagegroup_snap(
array, source_group, snap_name, extra_specs)
def delete_group_replica(self, array, snap_name, source_group_name,
src_dev_ids, extra_specs):
"""Delete the snapshot.
:param array: the array serial number
:param snap_name: the name for the snap shot
:param source_group_name: the source group name
:param src_dev_ids: the list of source device ids
:param extra_specs: extra specifications
"""
# Delete snapvx snapshot
LOG.debug("Deleting Snap Vx snapshot: source group: %(srcGroup)s "
"snapshot: %(snap_name)s.",
{'srcGroup': source_group_name, 'snap_name': snap_name})
self.delete_volume_snap_check_for_links(
array, snap_name, src_dev_ids, extra_specs)
def link_and_break_replica(self, array, source_group_name,
target_group_name, snap_name, extra_specs,
list_volume_pairs, delete_snapshot=False):
"""Links a group snap and breaks the relationship.
:param array: the array serial
:param source_group_name: the source group name
:param target_group_name: the target group name
:param snap_name: the snapshot name
:param extra_specs: extra specifications
:param list_volume_pairs: the list of volume pairs
:param delete_snapshot: delete snapshot flag
"""
LOG.debug("Linking Snap Vx snapshot: source group: %(srcGroup)s "
"targetGroup: %(tgtGroup)s.",
{'srcGroup': source_group_name,
'tgtGroup': target_group_name})
# Link the snapshot
self.rest.modify_volume_snap(
array, None, None, snap_name, extra_specs, link=True,
list_volume_pairs=list_volume_pairs)
# Unlink the snapshot
LOG.debug("Unlinking Snap Vx snapshot: source group: %(srcGroup)s "
"targetGroup: %(tgtGroup)s.",
{'srcGroup': source_group_name,
'tgtGroup': target_group_name})
self._unlink_volume(array, None, None, snap_name, extra_specs,
list_volume_pairs=list_volume_pairs)
# Delete the snapshot if necessary
if delete_snapshot:
LOG.debug("Deleting Snap Vx snapshot: source group: %(srcGroup)s "
"snapshot: %(snap_name)s.",
{'srcGroup': source_group_name,
'snap_name': snap_name})
source_devices = [a for a, b in list_volume_pairs]
self.delete_volume_snap(array, snap_name, source_devices)
def enable_group_replication(self, array, storagegroup_name,
rdf_group_num, extra_specs, establish=False):
"""Resume rdf replication on a storage group.
Replication is enabled by default. This allows resuming
replication on a suspended group.
:param array: the array serial number
:param storagegroup_name: the storagegroup name
:param rdf_group_num: the rdf group number
:param extra_specs: the extra specifications
:param establish: flag to indicate 'establish' instead of 'resume'
"""
action = "Establish" if establish is True else "Resume"
self.rest.modify_storagegroup_rdf(
array, storagegroup_name, rdf_group_num, action, extra_specs)
def disable_group_replication(self, array, storagegroup_name,
rdf_group_num, extra_specs):
"""Suspend rdf replication on a storage group.
This does not delete the rdf pairs, that can only be done
by deleting the group. This method suspends all i/o activity
on the rdf links.
:param array: the array serial number
:param storagegroup_name: the storagegroup name
:param rdf_group_num: the rdf group number
:param extra_specs: the extra specifications
"""
action = "Suspend"
self.rest.modify_storagegroup_rdf(
array, storagegroup_name, rdf_group_num, action, extra_specs)
def failover_group(self, array, storagegroup_name,
rdf_group_num, extra_specs, failover=True):
"""Failover or failback replication on a storage group.
:param array: the array serial number
:param storagegroup_name: the storagegroup name
:param rdf_group_num: the rdf group number
:param extra_specs: the extra specifications
:param failover: flag to indicate failover/ failback
"""
action = "Failover" if failover else "Failback"
self.rest.modify_storagegroup_rdf(
array, storagegroup_name, rdf_group_num, action, extra_specs)
def delete_group_replication(self, array, storagegroup_name,
rdf_group_num, extra_specs):
"""Split replication for a group and delete the pairs.
:param array: the array serial number
:param storagegroup_name: the storage group name
:param rdf_group_num: the rdf group number
:param extra_specs: the extra specifications
"""
group_details = self.rest.get_storage_group_rep(
array, storagegroup_name)
if (group_details and group_details.get('rdf')
and group_details['rdf'] is True):
action = "Split"
LOG.debug("Splitting remote replication for group %(sg)s",
{'sg': storagegroup_name})
self.rest.modify_storagegroup_rdf(
array, storagegroup_name, rdf_group_num, action, extra_specs)
LOG.debug("Deleting remote replication for group %(sg)s",
{'sg': storagegroup_name})
self.rest.delete_storagegroup_rdf(
array, storagegroup_name, rdf_group_num)
def revert_volume_snapshot(self, array, source_device_id,
snap_name, extra_specs):
"""Revert a volume snapshot
:param array: the array serial number
:param source_device_id: device id of the source
:param snap_name: snapvx snapshot name
:param extra_specs: the extra specifications
"""
start_time = time.time()
self.rest.modify_volume_snap(
array, source_device_id, "", snap_name, extra_specs, restore=True)
LOG.debug("Restore volume snapshot took: %(delta)s H:MM:SS.",
{'delta': self.utils.get_time_delta(start_time,
time.time())})
| {
"content_hash": "27a6170ffc5a6fb0b07e72158a389cda",
"timestamp": "",
"source": "github",
"line_count": 772,
"max_line_length": 78,
"avg_line_length": 42.6800518134715,
"alnum_prop": 0.5756472123584935,
"repo_name": "phenoxim/cinder",
"id": "b356bbd4ca2719990a8da6ae8986c6d81ea62209",
"size": "33599",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "cinder/volume/drivers/dell_emc/vmax/provision.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Makefile",
"bytes": "621"
},
{
"name": "Python",
"bytes": "20325688"
},
{
"name": "Shell",
"bytes": "16353"
}
],
"symlink_target": ""
} |
import argparse
import re
import sys
import os
import difflib
import const
def main(argv):
# define return code const value
const.CheckPassFail = 1
const.CheckPassOK = 0
const.GeneralError = -1
const.UnknownArguments = -2
const.MissingResult = -3
# Parse the command line
parser = argparse.ArgumentParser()
required = parser.add_argument_group('required arguments')
required.add_argument('-b', '--base-result-path', type=str, required=True,
help='full path to base result')
required.add_argument('-d', '--diff-result-path', type=str, required=True,
help='full path to diff result')
args, unknown = parser.parse_known_args(argv)
if unknown:
print('Unknown argument(s): ', ', '.join(unknown))
return const.UnknownArguments
try:
# Collect a list of summary result file relative path in base result
base_files = []
for root, dirs, files in os.walk(args.base_result_path):
for file in files:
if file.endswith('sum.txt'):
relative_path = os.path.relpath(root, args.base_result_path)
relative_path = os.path.join(relative_path, file)
base_files.append(relative_path)
# Collect a list of summary result file relative path in diff result
diff_files = []
for root, dirs, files in os.walk(args.diff_result_path):
for file in files:
if file.endswith('sum.txt'):
relative_path = os.path.relpath(root, args.diff_result_path)
relative_path = os.path.join(relative_path, file)
diff_files.append(relative_path)
except:
e = sys.exc_info()[0]
print('Error: CheckPass failed due to ', e)
return const.GeneralError
# Check if results are empty
if len(base_files) == 0:
print('Error: base result is empty')
return const.MissingResult
if len(diff_files) == 0:
print('Error: diff result is empty')
return const.MissingResult
# Counting the newly failed or passed test cases
count_new_failed = 0
count_new_passed = 0
print('Checking started.')
for file in base_files:
if file in diff_files:
try:
base_file_path = os.path.join(args.base_result_path, file)
diff_file_path = os.path.join(args.diff_result_path, file)
with open(base_file_path, 'r') as bases, open(diff_file_path, 'r') as diffs:
diff = difflib.ndiff(bases.readlines(),diffs.readlines())
for line in diff:
if re.search('- Successfully read ', line):
count_new_failed = count_new_failed + 1
if re.search('\+ Successfully read ', line):
count_new_passed = count_new_passed + 1
except:
e = sys.exc_info()[0]
print('Error: CheckPass failed due to ', e)
return const.GeneralError
else:
missing_result_file = os.path.join(args.diff_result_path, file)
print('Error: diff result does not result file ', missing_result_file)
return const.MissingResult
print('CheckPass: ', count_new_failed, ' test cases passed in base result but failed in diff result.')
print('CheckPass: ', count_new_passed, ' test cases failed in base result but passed in diff result.')
if count_new_failed == 0:
print('CheckPass Passed.')
return const.CheckPassOK
else:
print('CheckPass Failed.\n')
return const.CheckPassFail
if __name__ == '__main__':
return_code = main(sys.argv[1:])
sys.exit(return_code)
| {
"content_hash": "1884a5b8b647f01eec8041cdb4954bfa",
"timestamp": "",
"source": "github",
"line_count": 98,
"max_line_length": 107,
"avg_line_length": 39.214285714285715,
"alnum_prop": 0.581056466302368,
"repo_name": "libengu/llilc",
"id": "7336c6e1eb2aae34f51cb3ee36bcaeac1c6e6cf0",
"size": "4974",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "test/llilc_checkpass.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "C",
"bytes": "83708"
},
{
"name": "C++",
"bytes": "936901"
},
{
"name": "CMake",
"bytes": "19945"
},
{
"name": "PowerShell",
"bytes": "33960"
},
{
"name": "Python",
"bytes": "27935"
},
{
"name": "Shell",
"bytes": "310"
}
],
"symlink_target": ""
} |
import numpy as np
import tvm
from tvm import relay
from tvm.relay import transform
def run_opt_pass(expr, opt_pass):
assert isinstance(opt_pass, transform.Pass)
mod = relay.Module.from_expr(expr)
mod = opt_pass(mod)
entry = mod["main"]
return entry if isinstance(expr, relay.Function) else entry.body
def test_fold_const():
c_data = np.array([1, 2, 3]).astype("float32")
t = relay.TensorType([1, 2, 3], "float32")
def before():
c = relay.const(c_data)
x = relay.var("x", t)
y = relay.add(c, c)
y = relay.multiply(y, relay.const(2, "float32"))
y = relay.add(x, y)
z = relay.add(y, c)
return relay.Function([x], z)
def expected():
x = relay.var("x", t)
c_folded = (c_data + c_data) * 2
y = relay.add(x, relay.const(c_folded))
z = relay.add(y, relay.const(c_data))
return relay.Function([x], z)
def fail(x):
raise RuntimeError()
# the fold constant should work on any context.
with tvm.build_config(add_lower_pass=[(0, fail)]):
with tvm.target.create("cuda"):
zz = run_opt_pass(before(), transform.FoldConstant())
zexpected = run_opt_pass(expected(), transform.InferType())
assert relay.analysis.alpha_equal(zz, zexpected)
def test_fold_let():
c_data = np.array(1).astype("float32")
t = relay.TensorType([1], "float32")
def before():
sb = relay.ScopeBuilder()
x = relay.var("x", t)
t1 = sb.let("t1", relay.const(c_data))
t2 = sb.let("t2", relay.add(t1, t1))
t3 = sb.let("t3", relay.add(t2, x))
sb.ret(t3)
return relay.Function([x], sb.get())
def expected():
sb = relay.ScopeBuilder()
x = relay.var("x", t)
c_folded = (c_data + c_data)
t3 = sb.let("t3", relay.add(relay.const(c_folded), x))
sb.ret(t3)
return relay.Function([x], sb.get())
zz = run_opt_pass(before(), transform.FoldConstant())
zexpected = run_opt_pass(expected(), transform.InferType())
assert relay.analysis.graph_equal(zz, zexpected)
def test_fold_tuple():
c_data = np.array(1).astype("float32")
t = relay.TensorType([1], "float32")
def before():
c = relay.const(c_data)
x = relay.var("x", t)
y = relay.Tuple([x, c])
z = relay.add(y[1], c)
z = relay.add(z, y[0])
return relay.Function([x], z)
def expected():
c = relay.const(c_data + c_data)
x = relay.var("x", t)
z = relay.add(c, x)
return relay.Function([x], z)
zz = run_opt_pass(before(), transform.FoldConstant())
zexpected = run_opt_pass(expected(), transform.InferType())
assert relay.analysis.graph_equal(zz, zexpected)
def test_fold_concat():
c_data = np.array([[1, 2, 3]]).astype("float32")
def before():
a = relay.const(c_data)
b = relay.const(c_data)
y = relay.concatenate((a, b), axis=0)
return relay.Function([], y)
def expected():
y_data = np.concatenate((c_data, c_data), axis=0)
y = relay.const(y_data)
return relay.Function([], y)
zz = run_opt_pass(before(), transform.FoldConstant())
zexpected = run_opt_pass(expected(), transform.InferType())
assert relay.analysis.graph_equal(zz, zexpected)
def test_fold_shape_of():
c_shape = (8, 9, 10)
def before(dtype):
x = relay.var("x", shape=c_shape, dtype="float32")
y = relay.var("y", shape=c_shape, dtype="float32")
z = relay.shape_of(x + y, dtype)
return relay.Function([x, y], z)
def expected(dtype):
x = relay.var("x", shape=c_shape, dtype="float32")
y = relay.var("y", shape=c_shape, dtype="float32")
z = relay.const(np.array(c_shape).astype(dtype), dtype=dtype)
func = relay.Function([x, y], z)
return func
for dtype in ["int32", "float32"]:
zz = run_opt_pass(before(dtype), transform.FoldConstant())
zexpected = run_opt_pass(expected(dtype), transform.InferType())
assert relay.analysis.graph_equal(zz, zexpected)
if __name__ == "__main__":
test_fold_const()
test_fold_let()
test_fold_tuple()
test_fold_concat()
test_fold_shape_of()
| {
"content_hash": "43c0b6be18c13005db9a6f0f8fb2107c",
"timestamp": "",
"source": "github",
"line_count": 138,
"max_line_length": 72,
"avg_line_length": 30.985507246376812,
"alnum_prop": 0.5762394761459307,
"repo_name": "Huyuwei/tvm",
"id": "97b20c6b9219a91ec21f2076a681a84b1f5fd1a5",
"size": "5061",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "tests/python/relay/test_pass_fold_constant.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "ANTLR",
"bytes": "6056"
},
{
"name": "C",
"bytes": "95567"
},
{
"name": "C++",
"bytes": "5569606"
},
{
"name": "CMake",
"bytes": "67305"
},
{
"name": "Go",
"bytes": "112376"
},
{
"name": "HTML",
"bytes": "8625"
},
{
"name": "Java",
"bytes": "173219"
},
{
"name": "JavaScript",
"bytes": "49801"
},
{
"name": "Makefile",
"bytes": "50818"
},
{
"name": "Objective-C",
"bytes": "15264"
},
{
"name": "Objective-C++",
"bytes": "46673"
},
{
"name": "Python",
"bytes": "6775044"
},
{
"name": "Rust",
"bytes": "182027"
},
{
"name": "Scala",
"bytes": "184105"
},
{
"name": "Shell",
"bytes": "96633"
},
{
"name": "Tcl",
"bytes": "53645"
},
{
"name": "Verilog",
"bytes": "30605"
}
],
"symlink_target": ""
} |
import os, platform
import dynamixel
import time
import options
import math
import serial
ticks_per_rad = 4096.0/(math.pi*2)
############################################
# _______ __ ______ __
# /_ __(_)_ _ / // / __ \_ _____ ________/ /
# / / / / ' \ / _ / /_/ / |/|/ / _ `/ __/ _ /
# /_/ /_/_/_/_/ /_//_/\____/|__,__/\_,_/_/ \_,_/
############################################
myActuators = list()
def forwardKinematics(theta1, theta2, l1, l2):
return [l1*math.cos(theta1)+l2*(math.cos(theta1+theta2)),
l1*math.sin(theta1)+l2*(math.sin(theta1+theta2))]
#Given: xE,yE, l1, l2
#Return: theta1,theta2
def inverseKinematics(xIn, yIn, l1, l2):
myTheta2 = 2*math.atan2(math.sqrt(((l1+l2)**2-(xIn**2+yIn**2))),math.sqrt((xIn**2+yIn**2.0)-(l1-l2)**2))
myTheta1 = math.atan2(yIn,xIn)-math.atan2(l2*math.sin(myTheta2),l1+l2*math.cos(myTheta2))
return (scaleToCircle(myTheta1), scaleToCircle(myTheta2))
def computeAltIK(x, y, theta1, theta2):
#theta1 and 2 are IK outputs
t2 = -theta2
angle_to_endpoint = scaleToCircle(math.atan2(y,x))
if angle_to_endpoint > theta1:
t1 = theta1 + 2*(angle_to_endpoint-theta1)
elif angle_to_endpoint < theta1:
t1 = theta1 + 2*(angle_to_endpoint-theta1)
else:
t1 = theta1
return (t1, t2)
def scaleToCircle(radianvalue):
return radianvalue % (2*math.pi)
def boundWithinGoal(value, upper, lower):
if value > upper:
bounded = upper
elif value < lower:
bounded = lower
else:
bounded = value
return bounded
def boundWithinRobotReach(x, y, radius):
if math.sqrt(math.pow(x,2)+math.pow(y,2)) > radius:
angle = math.atan2(y,x)
return (0.98*radius*math.cos(angle), 0.98*radius*math.sin(angle))
else:
return (x,y)
def withinThreshold(difference, thresh):
if abs(difference) <= thresh:
return True
elif abs(abs(difference)-2*math.pi) <= thresh:
return True
else:
return False
def actuatorsMoving(actuators):
for actuator in actuators:
if actuator.cache[dynamixel.defs.REGISTER['Moving']]:
return True
return False
if platform.dist()[0] == 'Ubuntu':
portName = options.ubuntu_port
elif os.name == "posix":
portName = options.unix_port
else:
portName = options.windows_port
serial = dynamixel.serial_stream.SerialStream( port=portName, baudrate=options.baudrate, timeout=1)
net = dynamixel.dynamixel_network.DynamixelNetwork( serial )
net.scan( 1, options.num_servos )
print "Scanning for Dynamixels...",
for dyn in net.get_dynamixels():
print dyn.id,
myActuators.append(net[dyn.id])
print "FOUND:" + str(myActuators)
for actuator in myActuators:
actuator.moving_speed = options.servo_speed
actuator.synchronized = True
actuator.torque_enable = True
actuator.torque_control_enable = False
actuator.torque_limit = 1024
actuator.max_torque = 1024
class Arm(object):
def __init__(self, shoulder, elbow, params):
self.params = params
self.shoulder = shoulder
self.elbow = elbow
self.elbow_angle = 0
self.shoulder_angle = 0
#motors
def update(self):
net.synchronize()
self.shoulder.read_all()
self.elbow.read_all()
def moveToXY(self,x,y):
theta1, theta2 = inverseKinematics(x,y, self.params.l1, self.params.l2)
(shoulderCurr, elbowCurr) = self.returnCurrentPositions()
(shoulderCurrNOMOD, elbowCurrNOMOD) = self.returnCurrentPositionsNOMOD()
alpha = shoulderCurr - theta1
if abs(alpha) > abs(shoulderCurr - (theta1+2*math.pi)):
alpha = shoulderCurr - (theta1+2*math.pi)
if abs(alpha) > abs(shoulderCurr - (theta1-2*math.pi)):
alpha = shoulderCurr - (theta1-2*math.pi)
beta = elbowCurr - theta2
if abs(beta) > abs(elbowCurr - (theta2+2*math.pi)):
beta = elbowCurr - (theta2+2*math.pi)
if abs(beta) > abs(elbowCurr - (theta2-2*math.pi)):
beta = elbowCurr - (theta2-2*math.pi)
self.moveToTheta(shoulderCurrNOMOD-alpha, elbowCurrNOMOD-beta)
def moveToXYGoal(self, x, y):
x, y = Arm.transformGoaltoRobot(self,x,y)
x, y = boundWithinRobotReach(x,y, self.params.l1+self.params.l2)
x = boundWithinGoal(x, self.params.max_x, self.params.min_x)
y = boundWithinGoal(y, self.params.max_y, self.params.min_y)
self.moveToXY(x,y)
def transformGoaltoRobot(self,x,y):
return (x-self.params.horizontal_offset, y-self.params.vertical_offset)
def moveToTheta(self, t1, t2):
#print t1, t2
self.shoulder_angle = t1
self.elbow_angle = t2
self.shoulder.goal_position = int((self.shoulder_angle*ticks_per_rad)+self.params.shoulder_offset)
self.elbow.goal_position = int(((self.elbow_angle*ticks_per_rad) +self.params.elbow_offset)/2)
def isMoving(self):
for actuator in [self.shoulder, self.elbow]:
if actuator.cache[dynamixel.defs.REGISTER['Moving']]:
return True
return False
def returnCurrentPositions(self):
theta1 = (self.shoulder.cache[dynamixel.defs.REGISTER['CurrentPosition']]-self.params.shoulder_offset)/ticks_per_rad
theta2 = (self.elbow.cache[dynamixel.defs.REGISTER['CurrentPosition']]-self.params.elbow_offset)/ticks_per_rad*2
theta1 = scaleToCircle(theta1)
theta2 = scaleToCircle(theta2)
return (theta1, theta2)
def returnCurrentPositionsNOMOD(self):
theta1 = (self.shoulder.cache[dynamixel.defs.REGISTER['CurrentPosition']]-self.params.shoulder_offset)/ticks_per_rad
theta2 = (self.elbow.cache[dynamixel.defs.REGISTER['CurrentPosition']]-self.params.elbow_offset)/ticks_per_rad*2
return (theta1, theta2)
def nearGoalPosition(self):
shoulder, elbow = Arm.returnCurrentPositions(self)
if withinThreshold(scaleToCircle(shoulder-self.shoulder_angle),self.params.angle_threshold) and withinThreshold(scaleToCircle(elbow-self.elbow_angle),self.params.angle_threshold):
return True
else:
return False
a = Arm(myActuators[0], myActuators[1], options.left_arm)
b = Arm(myActuators[2], myActuators[3], options.right_arm)
a.update()
b.update()
points = [[55,0],[50,0],[45,0],[40,0],[35,0],[30,0],[25,0],[20,0],[15,0],[10,0],[5,0]]
goal = [60,0]
t = time.time()
raw_input("Press any key to start")
while True:
try:
(theta1_left, theta2_left) = a.returnCurrentPositions()
(theta1_right, theta2_right) = b.returnCurrentPositions()
currXY_left = forwardKinematics(theta1_left, theta2_left, options.left_arm.l1, options.left_arm.l2) #in robot coords
currXY_left_world = [currXY_left[0]+options.left_arm.horizontal_offset, currXY_left[1]+options.left_arm.vertical_offset]
gamma_left = math.atan2(goal[1]-currXY_left_world[1], goal[0]-currXY_left_world[0])
currXY_right = forwardKinematics(theta1_right, theta2_right, options.right_arm.l1, options.right_arm.l2) #in robot coords
currXY_right_world = [currXY_right[0]+options.right_arm.horizontal_offset, currXY_right[1]+options.right_arm.vertical_offset]
gamma_right = math.atan2(goal[1]-currXY_right_world[1], goal[0]-currXY_right_world[0])
l_left=4
l_right=4
if( ((goal[1]-currXY_left_world[1])**2 + (goal[0]-currXY_left_world[0])**2) < l_left**2):
l_left = math.sqrt((goal[1]-currXY_left_world[1])**2 + (goal[0]-currXY_left_world[0])**2)
if ( ((goal[1]-currXY_right_world[1])**2 + (goal[0]-currXY_right_world[0])**2) < l_right**2):
l_right = math.sqrt((goal[1]-currXY_right_world[1])**2 + (goal[0]-currXY_right_world[0])**2)
a.moveToXYGoal(currXY_left_world[0]+l_left*math.cos(gamma_left), currXY_left_world[1]+l_left*math.sin(gamma_left))
b.moveToXYGoal(currXY_right_world[0]+l_right*math.cos(gamma_right), currXY_right_world[1]+l_right*math.sin(gamma_right))
a.update()
b.update()
'''
if time.time() > 1+t:
goal = points.pop()
t = time.time()
'''
except KeyboardInterrupt:
break
| {
"content_hash": "76f3fae479463a7d15e9a840bb7e7d10",
"timestamp": "",
"source": "github",
"line_count": 231,
"max_line_length": 181,
"avg_line_length": 33.004329004329,
"alnum_prop": 0.6798268625393494,
"repo_name": "skyleradams/tim-howard",
"id": "65d9f24001b36ba44760cb925e4fd74451e9073b",
"size": "7624",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "Python/dynamixel_control.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Arduino",
"bytes": "12766"
},
{
"name": "Matlab",
"bytes": "943"
},
{
"name": "Python",
"bytes": "50167"
}
],
"symlink_target": ""
} |
import logging
if __name__ == '__main__':
logging.basicConfig()
_log = logging.getLogger(__name__)
import pyxb.binding.generate
import pyxb.binding.datatypes as xs
import pyxb.binding.basis
import pyxb.utils.domutils
import os.path
xsd='''<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="tEmpty">
<xs:attribute name="units" type="xs:string" use="required"/>
</xs:complexType>
<xs:element name="Empty" type="tEmpty"/>
<xs:complexType name="tMixed" mixed="true">
<xs:attribute name="units" type="xs:string" use="required"/>
</xs:complexType>
<xs:element name="Mixed" type="tMixed"/>
<xs:complexType name="tSimple">
<xs:simpleContent>
<xs:extension base="xs:double">
<xs:attribute name="units" type="xs:string" use="required"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:element name="Simple" type="tSimple" nillable="true"/>
<xs:element name="Something"/>
</xs:schema>'''
code = pyxb.binding.generate.GeneratePython(schema_text=xsd)
#open('code.py', 'w').write(code)
#print code
rv = compile(code, 'test', 'exec')
eval(rv)
from pyxb.exceptions_ import *
import unittest
class TestTrac_200907231705 (unittest.TestCase):
def testParsing (self):
xml = '<Empty units="m"/>'
instance = CreateFromDocument(xml)
self.assertEqual(pyxb.binding.basis.complexTypeDefinition._CT_EMPTY, instance._ContentTypeTag)
self.assertTrue(instance.validateBinding())
xml = '<Empty units="m">5</Empty>'
self.assertRaises(pyxb.MixedContentError, CreateFromDocument, xml)
xml = '<Mixed units="m"/>'
instance = CreateFromDocument(xml)
self.assertEqual(pyxb.binding.basis.complexTypeDefinition._CT_MIXED, instance._ContentTypeTag)
xml = '<Mixed units="m">5</Mixed>'
instance = CreateFromDocument(xml)
self.assertEqual(pyxb.binding.basis.complexTypeDefinition._CT_MIXED, instance._ContentTypeTag)
self.assertEqual(u'5', instance.orderedContent()[0].value)
xml = '<Mixed units="m">5<Something/>4</Mixed>'
self.assertRaises(pyxb.UnrecognizedContentError, CreateFromDocument, xml)
xml = '<Simple units="m"/>'
self.assertRaises(pyxb.SimpleContentAbsentError, CreateFromDocument, xml)
def testCtorEmpty (self):
instance = Empty()
self.assertRaises(pyxb.AttributeValidationError, instance.validateBinding)
instance = Empty(units='m')
self.assertTrue(instance.validateBinding())
self.assertRaises(pyxb.MixedContentError, Empty, 4, units='m')
def testCtorMixed (self):
instance = Mixed()
self.assertRaises(pyxb.AttributeValidationError, instance.validateBinding)
instance = Mixed(units='m')
self.assertTrue(instance.validateBinding())
instance = Mixed(4, units='m')
self.assertTrue(instance.validateBinding())
self.assertEqual(u'4', instance.orderedContent()[0].value)
instance = Mixed(xs.int(4), units='m')
self.assertTrue(instance.validateBinding())
self.assertEqual(u'4', instance.orderedContent()[0].value)
def testCtorSimple (self):
self.assertRaises(pyxb.SimpleContentAbsentError, Simple)
instance = Simple(4)
self.assertRaises(pyxb.AttributeValidationError, instance.validateBinding)
self.assertRaises(pyxb.SimpleContentAbsentError, Simple, units='m')
instance = Simple(4.5, units='m')
self.assertEqual(4.5, instance.value())
def testParsingNil (self):
xml = '<Simple xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true" units="m"/>'
instance = CreateFromDocument(xml)
self.assertEqual(pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE, instance._ContentTypeTag)
self.assertTrue(instance.validateBinding())
self.assertTrue(instance.value() is None)
if __name__ == '__main__':
unittest.main()
| {
"content_hash": "d085b759fb0a47b4f7d6d3da86a791ec",
"timestamp": "",
"source": "github",
"line_count": 98,
"max_line_length": 104,
"avg_line_length": 40.80612244897959,
"alnum_prop": 0.6799199799949988,
"repo_name": "jonfoster/pyxb-upstream-mirror",
"id": "0c06be75895c8c0e80ac308190077614d1cf0f16",
"size": "4023",
"binary": false,
"copies": "3",
"ref": "refs/heads/master",
"path": "tests/bugs/test-200907231705.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Perl",
"bytes": "6286"
},
{
"name": "Python",
"bytes": "1854695"
},
{
"name": "Shell",
"bytes": "37524"
}
],
"symlink_target": ""
} |
import os
from django.http import FileResponse
from wsgiref.util import FileWrapper
from settings.static import MEDIA_URL
# from django.core.servers.basehttp import FileWrapper
from django.views.generic import TemplateView
from django.shortcuts import render_to_response, render, redirect, get_object_or_404
from django.core.mail import send_mail
from django.http import HttpResponse
from django.template import RequestContext
from django.http import HttpResponseRedirect
from pangolinfog.forms import *
# from pangolinfog.recaptcha.forms import *
from django.template.loader import get_template
from django.core.mail import EmailMessage
from django.template import Context
from product.models import Category
from product.models import Product, Accessory
from content.models import Slide
from django.core.urlresolvers import reverse_lazy
from django.views.generic import FormView
from nocaptcha_recaptcha.fields import NoReCaptchaField
def contact(request):
form_class = ContactForm
success_url = reverse_lazy('success')
args = {}
background_image = get_object_or_404(Slide, header_about=1)
args['menu'] = "contact"
categories_main_menu = Category.objects.filter(published_in_menu=1).order_by('ordering')
args['categories_main_menu'] = categories_main_menu
args['form'] = form_class
args['background_image'] = background_image
def form_valid(self, form):
return super(form_class, self).form_valid(form)
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
contact_name = request.POST.get(
'contact_name'
, '')
contact_email = request.POST.get(
'contact_email'
, '')
contact_phone = request.POST.get(
'contact_phone'
, '')
form_content = request.POST.get('content', '')
# Email the profile with the
# contact information
template = get_template('contact_template.txt')
context = Context({
'contact_name': contact_name,
'contact_email': contact_email,
'contact_phone': contact_phone,
'form_content': form_content,
})
content = template.render(context)
email = EmailMessage(
"Pangolin Fog",
content,
"Pangolin Fog" +'',
['[email protected]'],
headers = {'Reply-To': contact_email }
)
email.send()
return redirect(request.META.get('HTTP_REFERER', '/'))
return render(request, 'contact.html', args)
def jq_subsc(request):
return render(request, 'jq_subsc.html')
def download_file(request):
_file = 'manualtourhazer2.pdf.zip'
filename = os.path.basename(_file)
# python 3
# response = FileResponse(FileWrapper(open(filename, 'rb')), content_type='application/x-zip-compressed')
# python 2
response = FileResponse(FileWrapper(file(filename, 'rb')), content_type='application/x-zip-compressed')
response['Content-Disposition'] = "attachment; filename=%s" % _file
return response
def download_mp3(request):
_file = 'Last_Summer_in_Yalta.mp3.zip'
filename = os.path.basename(_file)
# python 3
# response = FileResponse(FileWrapper(open(filename, 'rb')), content_type='application/x-zip-compressed')
# python 2
response = FileResponse(FileWrapper(file(filename, 'rb')), content_type='application/x-zip-compressed')
response['Content-Disposition'] = "attachment; filename=%s" % _file
return response
def main(request):
args = {}
slides = Slide.objects.filter(published_main=1).order_by('ordering')
categories_main_menu = Category.objects.filter(published_in_menu=1).order_by('ordering')
products_main = Product.objects.filter(published_main=1)
args['products_main'] = products_main
args['categories_main_menu'] = categories_main_menu
args['slides'] = slides
return render_to_response("home.html", args)
def news(request):
args = {}
slides = Slide.objects.filter(published_portfolio=1).order_by('ordering')
news = Slide.objects.filter(published_news=1).order_by('ordering')
background_image = get_object_or_404(Slide, header_about=1)
args['news'] = news
args['menu'] = "news"
args['slides'] = slides
args['background_image'] = background_image
return render_to_response("news.html", args)
def about(request):
args = {}
slides = Slide.objects.filter(published_portfolio=1).order_by('ordering')
news = Slide.objects.filter(published_news=1).order_by('ordering')
background_image = get_object_or_404(Slide, header_about=1)
args['news'] = news
args['menu'] = "about"
args['slides'] = slides
args['background_image'] = background_image
return render_to_response("about.html", args)
| {
"content_hash": "9e82a8819166fd3d58452cc7ce540c64",
"timestamp": "",
"source": "github",
"line_count": 161,
"max_line_length": 109,
"avg_line_length": 30.664596273291924,
"alnum_prop": 0.6631557626088718,
"repo_name": "skylifewww/pangolin-fog",
"id": "bcd55a954f444fac9d69945cc831a2aa6b45537a",
"size": "4937",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "pangolinfog/views.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "126434"
},
{
"name": "HTML",
"bytes": "154546"
},
{
"name": "JavaScript",
"bytes": "174324"
},
{
"name": "Makefile",
"bytes": "1483"
},
{
"name": "Nginx",
"bytes": "641"
},
{
"name": "Python",
"bytes": "177394"
}
],
"symlink_target": ""
} |
"""Helpers used to render lists.
"""
__authors__ = [
'"Daniel Hans" <[email protected]>',
'"Chen Lunpeng" <[email protected]>',
'"Sverre Rabbelier" <[email protected]>',
'"Pawel Solyga" <[email protected]>',
]
from django.utils import simplejson
from soc.logic import dicts
URL_PATTERN = '<a href="%(url)s"%(target)s%(nofollow)s>%(name)s</a>'
class IsNonEmptyRequest(object):
"""Request to check whether the list is non-empty."""
def __init__(self, idx):
self.idx = idx
self.GET = {}
self.POST = {}
def urlize(url, name=None, target="_blank", nofollow=True):
"""Make an url clickable.
Args:
url: the actual url, such as '/user/list'
name: the display name, such as 'List Users', defaults to url
target: the 'target' attribute of the <a> element
nofollow: whether to add the 'rel="nofollow"' attribute
"""
if not url:
return ''
from django.utils.safestring import mark_safe
from django.utils.html import escape
safe_url = escape(url)
safe_name = escape(name)
link = URL_PATTERN % {
'url': safe_url,
'name': safe_name if name else safe_url,
'target': ' target="%s"' % target if target else '',
'nofollow': ' rel="nofollow"' if nofollow else "",
}
return mark_safe(link)
def entityToRowDict(entity, key_order, no_filter, extra_cols_func,
button_ops_func, row_ops_func, args):
"""Returns the row dict for the specified entity.
"""
extra_cols = extra_cols_func(entity, *args)
button_ops = button_ops_func(entity, *args)
row_ops = row_ops_func(entity, *args)
fields = set(key_order).difference(set(extra_cols))
columns = entity.toDict(list(fields))
columns.update(extra_cols)
columns['key'] = str(entity.key().id_or_name())
filter_fields = [i for i in columns.keys() if i not in no_filter]
columns = dicts.cleanDict(columns, filter_fields)
operations = {
"row": row_ops,
"buttons": button_ops,
}
result = {
"columns": columns,
"operations": operations,
}
return result
def keyToColumnProperties(key, col_props, hidden):
"""Returns the column properties for the specified key.
"""
props = {
'name': key,
'index': key,
'resizable': True,
}
if key == 'key' or key in hidden:
props['hidden'] = True
if key in hidden:
props['searchoptions'] = {"searchhidden": True}
extra_props = col_props.get(key, {})
props.update(extra_props)
return props
def getKeyOrderAndColNames(params, visibility):
"""Retrieve key order and col names
"""
key_order = ["key"] + params.get('%s_field_keys' % visibility)
col_names = ["Key"] + params.get('%s_field_names' % visibility)
ignore = params.get('%s_field_ignore' % visibility, [])
for field in ignore:
if field not in key_order:
continue
pos = key_order.index(field)
key_order = key_order[:pos] + key_order[pos+1:]
col_names = col_names[:pos] + col_names[pos+1:]
if not (key_order and col_names):
key_order = col_names = ['kind']
return key_order, col_names
def isJsonRequest(request):
"""Returns true iff the request is a JSON request.
"""
if request.GET.get('fmt') == 'json':
return True
return False
def isDataRequest(request):
"""Returns true iff the request is a data request.
"""
if isJsonRequest(request):
return True
return False
def isNonEmptyRequest(request):
"""Returns true iff the request is a non-empty request.
"""
return isinstance(request, IsNonEmptyRequest)
def getListIndex(request):
"""Returns the index of the requested list.
"""
if isNonEmptyRequest(request):
return request.idx
idx = request.GET.get('idx', '')
idx = int(idx) if idx.isdigit() else -1
return idx
def getErrorResponse(request, msg):
"""Returns an error appropriate for the request type.
"""
from soc.views.helper import responses
if isJsonRequest(request):
return responses.jsonErrorResponse(request, msg)
raise Exception(msg)
def getResponse(request, contents):
"""Returns a response appropriate for the request type.
"""
from soc.views.helper import responses
if isJsonRequest(request):
json = simplejson.dumps(contents)
return responses.jsonResponse(request, json)
if isNonEmptyRequest(request):
return contents
# TODO(SRabbelier): this is probably the best way to handle this
return contents
def getListConfiguration(request, params, visibility, order):
"""Returns the list data for the specified params.
Args:
visibility: determines which list will be used
order: the order the data should be sorted in
"""
key_order, col_names = getKeyOrderAndColNames(params, visibility)
conf_extra = params.get('%s_conf_extra' % visibility, {})
conf_min_num = params.get('%s_conf_min_num' % visibility, 0)
button_global = params.get('%s_button_global' % visibility, [])
row_action = params.get('%s_row_action' % visibility, {})
col_props = params.get('%s_field_props' % visibility, {})
hidden = params.get('%s_field_hidden' % visibility, [])
col_model = [keyToColumnProperties(i, col_props, hidden) for i in key_order]
rowList = [5, 10, 20, 50, 100, 500, 1000]
rowList = [i for i in rowList if i >= conf_min_num]
rowNum = min(rowList)
sortorder = "asc"
sortname = order[0] if order else "key"
if sortname and sortname[0] == '-':
sortorder = "desc"
sortname = sortname[1:]
configuration = {
"autowidth": True,
"colModel": col_model,
"colNames": col_names,
"height": "auto",
"rowList": rowList,
"rowNum": max(1, rowNum),
"sortname": sortname,
"sortorder": sortorder,
"toolbar": [True, "top"],
"multiselect": False,
}
configuration.update(conf_extra)
operations = {
"buttons": button_global,
"row": row_action,
}
contents = {
'configuration': configuration,
'operations': operations,
}
return contents
def getListData(request, params, fields, visibility=None, args=[]):
"""Returns the list data for the specified params.
Args:
fields: a filter that should be applied to this list
visibility: determines which list will be used
args: list of arguments to be passed to extract funcs
"""
if not visibility:
visibility = 'public'
if not fields:
fields = {}
logic = params['logic']
if isNonEmptyRequest(request):
query = logic.getQueryForFields(filter=fields)
return query.count(1) > 0
get_args = request.GET
start = get_args.get('start', '')
limit = params.get('%s_conf_limit' % visibility)
if not limit:
limit = get_args.get('limit', 50)
limit = int(limit)
if start:
start_entity = logic.getFromKeyNameOrID(start)
if not start_entity:
return {'data': {start: []}}
fields['__key__ >'] = start_entity.key()
key_order, _ = getKeyOrderAndColNames(params, visibility)
column = params.get('%s_field_extra' % visibility, lambda *args: {})
row = params.get('%s_row_extra' % visibility, lambda *args: {})
button = params.get('%s_button_extra' % visibility, lambda *args: {})
no_filter = params.get('%s_field_no_filter' % visibility, [])
prefetch = params.get('%s_field_prefetch' % visibility, [])
entities = logic.getForFields(filter=fields, limit=limit, prefetch=prefetch)
extract_args = [key_order, no_filter, column, button, row, args]
columns = [entityToRowDict(i, *extract_args) for i in entities]
data = {
start: columns,
}
contents = {'data': data}
return contents
def getListGenerator(request, params, visibility=None, order=[], idx=0):
"""Returns a dict with fields used for rendering lists.
Args:
request: the Django HTTP request object
params: a dict with params for the View this list belongs to
idx: the index of this list
"""
if not visibility:
visibility = 'public'
configuration = getListConfiguration(request, params, visibility, order)
content = {
'idx': idx,
'configuration': simplejson.dumps(configuration),
'description': params['list_description'],
}
return content
| {
"content_hash": "c0b197e214df7ad8ee9f00fa27aa2d42",
"timestamp": "",
"source": "github",
"line_count": 339,
"max_line_length": 78,
"avg_line_length": 24.014749262536874,
"alnum_prop": 0.6552020636285468,
"repo_name": "SRabbelier/Melange",
"id": "7fab20130bb619b796330a2ccb81e75c20b79c31",
"size": "8751",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "app/soc/views/helper/lists.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "C",
"bytes": "400472"
},
{
"name": "C++",
"bytes": "20"
},
{
"name": "Java",
"bytes": "1496"
},
{
"name": "JavaScript",
"bytes": "1623582"
},
{
"name": "PHP",
"bytes": "1032"
},
{
"name": "Perl",
"bytes": "177565"
},
{
"name": "Python",
"bytes": "15317793"
},
{
"name": "Ruby",
"bytes": "59"
},
{
"name": "Shell",
"bytes": "15303"
}
],
"symlink_target": ""
} |
import logging
import os
import tempfile
from os.path import dirname, exists, join
from shutil import copy
from easyprocess import EasyProcess
from entrypoint2 import entrypoint
from PIL import Image # type: ignore
from eagexp import __version__
from eagexp.cmd import EagleError, command_eagle
from eagexp.util import norm_path, read_text, write_text
log = logging.getLogger(__name__)
log.debug("version=" + __version__)
@entrypoint
def export_image3d(
input, output, size=(800, 600), pcb_rotate=(0, 0, 0), timeout=20, showgui=False
):
"""
Exporting eagle .brd file into 3D image file
using Eagle3D and povray.
If export is blocked somehow (e.g. popup window is displayed) then after timeout operation is canceled with exception.
Problem can be investigated by setting 'showgui' flag.
:param input: eagle .brd file name
:param output: image file name (.png)
:param timeout: operation is canceled after this timeout (sec)
:param showgui: eagle GUI is displayed
:param size: tuple(width, size), image size
:rtype: None
"""
input = norm_path(input)
output = norm_path(output)
if not output.endswith(".png"):
raise ValueError("use .png extension!")
ext = os.path.splitext(input)[1]
if ext not in [".brd"]:
raise ValueError('Input extension is not ".brd", brd=' + str(input))
commands = []
eagle3d = join(dirname(__file__), "eagle3d")
ulp = norm_path(join(eagle3d, "3d50.ulp"))
if not exists(ulp):
raise EagleError("missing file:%s" % ulp)
commands += ["RUN " + ulp]
commands += ["QUIT"]
def render(dir, f):
# povray has strange file access policy,
# better to generate under tmp
# cli doc:
# http://library.thinkquest.org/3285/language/cmdln.html
templ = "#local pcb_rotate_%s = %s"
pov = f.replace(".brd", ".pov")
if not exists(pov):
raise EagleError("missing pov file: %s" % pov)
# log.debug("pov file %s content: %s", pov, pov.read_text())
if pcb_rotate != (0, 0, 0):
s = read_text(pov)
s = s.replace(templ % ("x", 0), templ % ("x", pcb_rotate[0]))
s = s.replace(templ % ("y", 0), templ % ("y", pcb_rotate[1]))
s = s.replace(templ % ("z", 0), templ % ("z", pcb_rotate[2]))
write_text(pov, s)
fpng = f.replace(".brd", ".png")
cmd = []
cmd += ["povray"]
cmd += ["-d"] # no display
cmd += ["-a"] # anti-aliasing
cmd += ["+W" + str(size[0])] # width
cmd += ["+H" + str(size[1])] # height
cmd += ["-o" + fpng]
cmd += ["-L" + eagle3d]
cmd += [pov]
p = EasyProcess(cmd).call()
if not exists(fpng):
raise EagleError("povray error, proc=%s" % p)
copy(fpng, output)
command_eagle(
input=input,
timeout=timeout,
commands=commands,
showgui=showgui,
callback=render,
)
def pil_image3d(
input, size=(800, 600), pcb_rotate=(0, 0, 0), timeout=20, showgui=False
):
"""
same as export_image3d, but there is no output file, PIL object is returned instead
"""
with tempfile.TemporaryDirectory() as temp_dir:
output = join(temp_dir, "out.png")
export_image3d(
input,
output=output,
size=size,
pcb_rotate=pcb_rotate,
timeout=timeout,
showgui=showgui,
)
im = Image.open(output)
return im
| {
"content_hash": "797c6c631d52a3b8bc22da49ba9eac10",
"timestamp": "",
"source": "github",
"line_count": 115,
"max_line_length": 122,
"avg_line_length": 30.878260869565217,
"alnum_prop": 0.5775837792171219,
"repo_name": "ponty/eagexp",
"id": "4146100ad9d19cb20a3d502752661017a021ac80",
"size": "3551",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "eagexp/image3d.py",
"mode": "33188",
"license": "bsd-2-clause",
"language": [
{
"name": "POV-Ray SDL",
"bytes": "1002650"
},
{
"name": "Python",
"bytes": "35571"
},
{
"name": "Ruby",
"bytes": "458"
},
{
"name": "Shell",
"bytes": "3259"
}
],
"symlink_target": ""
} |
import sys
import os
from glob import glob
import platform
def running_under_virtualenv():
if hasattr(sys, 'real_prefix'):
return True
elif sys.prefix != getattr(sys, "base_prefix", sys.prefix):
return True
if os.getenv('VIRTUAL_ENV', False):
return True
return False
if os.environ.get('USE_SETUPTOOLS'):
from setuptools import setup
setup_kwargs = dict(zip_safe=0)
else:
from distutils.core import setup
setup_kwargs = dict()
if os.name == 'nt':
pgm_files = os.environ["ProgramFiles"]
base_files = os.path.join(pgm_files, 'diamond')
data_files = [
(base_files, ['LICENSE', 'version.txt']),
(os.path.join(base_files, 'user_scripts'), []),
(os.path.join(base_files, 'conf'), glob('conf/*.conf.*')),
(os.path.join(base_files, 'collectors'), glob('conf/collectors/*')),
(os.path.join(base_files, 'handlers'), glob('conf/handlers/*')),
]
install_requires = ['configobj', 'psutil', ],
else:
data_files = [
('share/diamond', ['LICENSE', 'version.txt']),
('share/diamond/user_scripts', []),
]
distro = platform.dist()[0]
distro_major_version = platform.dist()[1].split('.')[0]
if not distro:
if 'amzn' in platform.uname()[2]:
distro = 'centos'
if running_under_virtualenv():
data_files.append(('etc/diamond',
glob('conf/*.conf.*')))
data_files.append(('etc/diamond/collectors',
glob('conf/collectors/*')))
data_files.append(('etc/diamond/handlers',
glob('conf/handlers/*')))
else:
data_files.append(('/etc/diamond',
glob('conf/*.conf.*')))
data_files.append(('/etc/diamond/collectors',
glob('conf/collectors/*')))
data_files.append(('/etc/diamond/handlers',
glob('conf/handlers/*')))
if distro == 'Ubuntu':
data_files.append(('/etc/init',
['debian/diamond.upstart']))
if distro in ['centos', 'redhat', 'debian', 'fedora', 'oracle']:
data_files.append(('/etc/init.d',
['bin/init.d/diamond']))
data_files.append(('/var/log/diamond',
['.keep']))
if distro_major_version >= 7 and not distro == 'debian':
data_files.append(('/usr/lib/systemd/system',
['rpm/systemd/diamond.service']))
elif distro_major_version >= 6 and not distro == 'debian':
data_files.append(('/etc/init',
['rpm/upstart/diamond.conf']))
# Support packages being called differently on different distros
# Are we in a virtenv?
if running_under_virtualenv():
install_requires = ['configobj', 'psutil', ]
else:
if distro == ['debian', 'ubuntu']:
install_requires = ['python-configobj', 'python-psutil', ]
# Default back to pip style requires
else:
install_requires = ['configobj', 'psutil', ]
def get_version():
"""
Read the version.txt file to get the new version string
Generate it if version.txt is not available. Generation
is required for pip installs
"""
try:
f = open('version.txt')
except IOError:
os.system("./version.sh > version.txt")
f = open('version.txt')
version = ''.join(f.readlines()).rstrip()
f.close()
return version
def pkgPath(root, path, rpath="/"):
"""
Package up a path recursively
"""
global data_files
if not os.path.exists(path):
return
files = []
for spath in os.listdir(path):
# Ignore test directories
if spath == 'test':
continue
subpath = os.path.join(path, spath)
spath = os.path.join(rpath, spath)
if os.path.isfile(subpath):
files.append(subpath)
if os.path.isdir(subpath):
pkgPath(root, subpath, spath)
data_files.append((root + rpath, files))
if os.name == 'nt':
pkgPath(os.path.join(base_files, 'collectors'), 'src/collectors', '\\')
else:
pkgPath('share/diamond/collectors', 'src/collectors')
version = get_version()
setup(
name='diamond',
version=version,
url='https://github.com/python-diamond/Diamond',
author='The Diamond Team',
author_email='[email protected]',
license='MIT License',
description='Smart data producer for graphite graphing package',
package_dir={'': 'src'},
packages=['diamond', 'diamond.handler', 'diamond.utils'],
scripts=['bin/diamond', 'bin/diamond-setup'],
data_files=data_files,
install_requires=install_requires,
classifiers=[
'Programming Language :: Python',
'Programming Language :: Python :: 2',
],
** setup_kwargs
)
| {
"content_hash": "3cbae3eba688723c8de4e27ea3395d06",
"timestamp": "",
"source": "github",
"line_count": 152,
"max_line_length": 76,
"avg_line_length": 32.80921052631579,
"alnum_prop": 0.5564467615801083,
"repo_name": "gg7/diamond",
"id": "0c4f2df06630896aaa0064db6c1ec6d3dd07de17",
"size": "5025",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "setup.py",
"mode": "33261",
"license": "mit",
"language": [
{
"name": "HTML",
"bytes": "21681"
},
{
"name": "Makefile",
"bytes": "4465"
},
{
"name": "Python",
"bytes": "1594105"
},
{
"name": "Roff",
"bytes": "23868"
},
{
"name": "Ruby",
"bytes": "230"
},
{
"name": "Shell",
"bytes": "12795"
}
],
"symlink_target": ""
} |
session.journalOptions.setValues(replayGeometry=COORDINATE,recoverGeometry=COORDINATE)
#-----------------------------------------------------
# Create a model.
modelName='GuoxiSuspensionBridge'
myModel = mdb.Model(name=modelName)
#-----------------------------------------------------
import GuoxiPackage.CreatePart
cp=GuoxiPackage.CreatePart.CreatePart(myModel)
#-----------------------------------------------------
| {
"content_hash": "282630538427eb795b0e8fb84217794e",
"timestamp": "",
"source": "github",
"line_count": 16,
"max_line_length": 86,
"avg_line_length": 26.5625,
"alnum_prop": 0.5129411764705882,
"repo_name": "zjkl19/AbaqusPython",
"id": "d1be97c7ff9fef4aa20d5064d8ce2a0a80bc8912",
"size": "627",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "GuoxiSuspensionBridge/GuoxiSuspensionBridge.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Batchfile",
"bytes": "512"
},
{
"name": "Python",
"bytes": "387298"
}
],
"symlink_target": ""
} |
import os
import shutil
import subprocess
import sys
import tempfile
def setup_git_repo(worktree=False):
git_repo_dir = tempfile.mkdtemp()
to_rm = [git_repo_dir]
try:
subprocess.check_output(["git", "init", "."], cwd=git_repo_dir)
with open(f"{git_repo_dir}/committed", "w") as committed_f:
committed_f.write("normal committed file\n")
subprocess.check_output(["git", "add", "committed"], cwd=git_repo_dir)
with open(f"{git_repo_dir}/committed-ignored", "w") as gitignore_f:
gitignore_f.write("this file is gitignored, but committed already")
subprocess.check_output(["git", "add", "committed-ignored"], cwd=git_repo_dir)
with open(f"{git_repo_dir}/.gitignore", "w") as gitignore_f:
gitignore_f.write("ignored\n" "committed-ignored\n")
subprocess.check_output(["git", "add", ".gitignore"], cwd=git_repo_dir)
# NOTE: explicitly set the author so this test passes in the CI.
subprocess.check_output(
[
"git",
"-c",
"user.name=Unit Test",
"-c",
"[email protected]",
"commit",
"-m",
"initial commit",
],
cwd=git_repo_dir,
)
if worktree:
worktree_dir = tempfile.mkdtemp()
to_rm.append(worktree_dir)
subprocess.check_output(["git", "worktree", "add", worktree_dir], cwd=git_repo_dir)
git_repo_dir = worktree_dir
with open(f"{git_repo_dir}/ignored", "w") as gitignore_f:
gitignore_f.write("this file is gitignored")
with open(f"{git_repo_dir}/added-to-index", "w") as added_f:
added_f.write("only added to git index\n")
subprocess.check_output(["git", "add", "added-to-index"], cwd=git_repo_dir)
with open(f"{git_repo_dir}/ignored-added-to-index", "w") as ignored_f:
ignored_f.write("this file is gitignored but in the index already\n")
subprocess.check_output(["git", "add", "-f", "ignored-added-to-index"], cwd=git_repo_dir)
with open(f"{git_repo_dir}/untracked", "w") as untracked_f:
untracked_f.write("this file is untracked\n")
os.mkdir(f"{git_repo_dir}/subdir")
with open(f"{git_repo_dir}/subdir/untracked", "w") as untracked_f:
untracked_f.write("this file is untracked\n")
with open(f"{git_repo_dir}/subdir/untracked2", "w") as untracked_f:
untracked_f.write("this file is also untracked\n")
return git_repo_dir, to_rm
except Exception:
for rm_dir in to_rm:
shutil.rmtree(rm_dir)
raise
def run_test(repo_path, passed_files, filtered_files):
test_input = (
"\n".join(
passed_files
+ filtered_files
+ [f"./{f}" for f in passed_files]
+ [f"./{f}" for f in filtered_files]
)
+ "\n"
)
test_script_dir = f"{repo_path}/test-script-dir"
os.mkdir(test_script_dir)
filter_script_path = f"{test_script_dir}/filter_untracked.py"
test_script_dirname = os.path.dirname(__file__) or os.getcwd()
shutil.copy(
os.path.realpath(f"{test_script_dirname}/../../lint/filter_untracked.py"),
filter_script_path,
)
filter_proc = subprocess.Popen(
[sys.executable, filter_script_path],
cwd=repo_path,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
encoding="utf-8",
)
filter_output, _ = filter_proc.communicate(test_input)
filter_output_lines = [l for l in filter_output.split("\n") if l]
for pass_f in passed_files:
assert (
pass_f in filter_output_lines
), f"expected in filter output: {pass_f}\filter output: {filter_output}"
assert (
f"./{pass_f}" in filter_output_lines
), f"expected in filter output: ./{pass_f}\filter output: {filter_output}"
for filter_f in filtered_files:
assert (
filter_f not in filter_output_lines
), f"expected not in filter output: {filter_f}\nfilter_output: {filter_output}"
assert (
f"./{filter_f}" not in filter_output_lines
), f"expected not in filter output: ./{filter_f}\nfilter_output: {filter_output}"
assert len(filter_output_lines) == 2 * len(
passed_files
), f"expected {len(filter_output_lines)} == 2 * {len(passed_files)}"
def test_filter_untracked():
repo_path, to_rm = setup_git_repo()
try:
passed_files = [
"committed",
"committed-ignored",
"added-to-index",
"ignored-added-to-index",
]
filtered_files = [
"ignored",
"untracked",
"subdir/untracked",
"subdir/untracked2",
]
run_test(repo_path, passed_files, filtered_files)
finally:
for rm_dir in to_rm:
shutil.rmtree(rm_dir)
def test_worktree():
repo_path, to_rm = setup_git_repo(worktree=True)
try:
passed_files = [
"committed",
"committed-ignored",
"added-to-index",
"ignored-added-to-index",
]
filtered_files = [
"ignored",
"untracked",
"subdir/untracked",
"subdir/untracked2",
".git",
]
run_test(repo_path, passed_files, filtered_files)
finally:
for rm_dir in to_rm:
shutil.rmtree(rm_dir)
if __name__ == "__main__":
test_filter_untracked()
test_worktree()
| {
"content_hash": "ee3f85b9c144076d30d96ba9d158ba56",
"timestamp": "",
"source": "github",
"line_count": 179,
"max_line_length": 97,
"avg_line_length": 31.75977653631285,
"alnum_prop": 0.55584872471416,
"repo_name": "tqchen/tvm",
"id": "6080a4193dc0d169d3c95783cf2bb1fac79a84da",
"size": "6471",
"binary": false,
"copies": "5",
"ref": "refs/heads/main",
"path": "tests/python/unittest/test_filter_untracked.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Batchfile",
"bytes": "4104"
},
{
"name": "C",
"bytes": "205781"
},
{
"name": "C++",
"bytes": "8124041"
},
{
"name": "CMake",
"bytes": "135007"
},
{
"name": "Cuda",
"bytes": "6677"
},
{
"name": "Go",
"bytes": "111558"
},
{
"name": "HTML",
"bytes": "2664"
},
{
"name": "Java",
"bytes": "200193"
},
{
"name": "JavaScript",
"bytes": "15075"
},
{
"name": "Makefile",
"bytes": "48206"
},
{
"name": "Objective-C",
"bytes": "18506"
},
{
"name": "Objective-C++",
"bytes": "56786"
},
{
"name": "Python",
"bytes": "10300435"
},
{
"name": "RenderScript",
"bytes": "1895"
},
{
"name": "Rust",
"bytes": "327078"
},
{
"name": "Shell",
"bytes": "157176"
},
{
"name": "TypeScript",
"bytes": "94435"
}
],
"symlink_target": ""
} |
from __main__ import vtk, qt, ctk, slicer
import string
import collections
import FeatureWidgetHelperLib
class CheckableTabWidget(qt.QTabWidget):
def __init__(self, parent=None):
super(CheckableTabWidget, self).__init__(parent)
self.featureClassFeatureWidgets = collections.OrderedDict()
# hack ( QTabWidget.setTabBar() and tabBar() are protected )
self.tab_bar = self.findChildren(qt.QTabBar)[0]
# Bold font style
self.boldFont = qt.QFont()
self.boldFont.setBold(True)
self.tab_bar.setFont(self.boldFont)
self.tab_bar.setContextMenuPolicy(3)
self.tab_bar.installEventFilter(self)
def addTab(self, widget, featureClass, featureWidgets, checkStatus=True):
qt.QTabWidget.addTab(self, widget, featureClass)
checkBox = FeatureWidgetHelperLib.FeatureWidget()
checkBox.Setup(featureName=featureClass, featureClassFlag=True, checkStatus=checkStatus)
self.featureClassFeatureWidgets[featureClass] = checkBox
self.tab_bar.setTabButton(self.tab_bar.count-1, qt.QTabBar.LeftSide, checkBox)
self.connect(checkBox, qt.SIGNAL('stateChanged(int)'), lambda checkState: self.stateChanged(checkBox, checkState, featureWidgets))
def isChecked(self, index):
return self.tab_bar.tabButton(index, qt.QTabBar.LeftSide).checkState() != 0
def setCheckState(self, index, checkState):
self.tab_bar.tabButton(index, qt.QTabBar.LeftSide).setCheckState(checkState)
def stateChanged(self, checkBox, checkState, featureWidgets):
# uncheck all checkboxes in QObject # may not need to pass list?
index = self.featureClassFeatureWidgets.values().index(checkBox)
if checkState == 0:
for widget in featureWidgets:
widget.checked = False
elif checkState == 2:
for widget in featureWidgets:
widget.checked = True
def eventFilter(self, object, event):
# context menu request (right-click) on QTabBar is forwarded to the QCheckBox (FeatureWidget)
if object == self.tab_bar and event.type() == qt.QEvent.ContextMenu:
tabIndex = object.tabAt(event.pos())
pos = self.featureClassFeatureWidgets.values()[tabIndex].mapFrom(self.tab_bar, event.pos())
if tabIndex > -1:
qt.QCoreApplication.sendEvent(self.featureClassFeatureWidgets.values()[tabIndex], qt.QContextMenuEvent(0, pos))
return True
return False
def getFeatureClassWidgets(self):
return(self.featureClassFeatureWidgets.values())
def addParameter(self, featureClass, parameter):
self.featureClassFeatureWidgets[featureClass].addParameter(parameter)
class FeatureWidget(qt.QCheckBox):
def __init__(self, parent=None):
super(FeatureWidget, self).__init__(parent)
def Setup(self, featureName="", featureClassFlag=False, checkStatus=True):
self.featureName = featureName
self.checked = checkStatus
if featureClassFlag:
self.descriptionLabel = FeatureWidgetHelperLib.FeatureClassDescriptionLabel()
self.descriptionLabel.setDescription(self.featureName)
else:
self.descriptionLabel = FeatureWidgetHelperLib.FeatureDescriptionLabel()
self.descriptionLabel.setDescription(self.featureName)
self.setText(self.featureName)
self.setContextMenuPolicy(3)
self.widgetMenu = FeatureWidgetHelperLib.ContextMenu(self)
self.widgetMenu.Setup(self.featureName, self.descriptionLabel)
self.customContextMenuRequested.connect(lambda point: self.connectMenu(point))
def connectMenu(self, pos):
self.widgetMenu.popup(self.mapToGlobal(pos))
def addParameter(self, parameterName):
self.widgetMenu.addParameter(parameterName)
def getParameterDict(self):
parameterDict = collections.OrderedDict()
for k,v in self.widgetMenu.parameters.items():
value = v['Edit Window'].getValue()
parameterDict[k] = value
return (parameterDict)
def getParameterEditWindow(self, parameterName):
return(self.widgetMenu.parameters[parameterName]['Edit Window'])
def getName(self):
return(self.featureName)
class ContextMenu(qt.QMenu):
def __init__(self, parent=None):
super(ContextMenu, self).__init__(parent)
def Setup(self, featureName, descriptionLabel="Description:"):
self.featureName = featureName
self.descriptionLabel = descriptionLabel
self.parameters = collections.OrderedDict()
self.descriptionAction = qt.QWidgetAction(self)
self.descriptionAction.setDefaultWidget(self.descriptionLabel)
self.closeAction = qt.QAction("Close", self)
self.reloadActions()
def reloadActions(self):
self.addAction(self.descriptionAction)
for parameter in self.parameters:
self.addAction(self.parameters[parameter]['Action'])
self.addAction(self.closeAction)
def addParameter(self, parameterName):
self.parameters[parameterName] = {}
self.parameters[parameterName]['Action'] = qt.QAction(('Edit %s' %parameterName), self)
self.parameters[parameterName]['Edit Window'] = FeatureWidgetHelperLib.ParameterEditWindow(self, self.featureName, parameterName)
self.parameters[parameterName]['Action'].connect('triggered()', lambda parameterName=parameterName: self.parameters[parameterName]['Edit Window'].showWindow())
self.reloadActions()
def getParameters(self):
return(self.parameters)
class ParameterEditWindow(qt.QInputDialog):
def __init__(self, parent=None, featureName="", parameterName=""):
super(ParameterEditWindow, self).__init__(parent)
self.featureName = featureName
self.parameterName = parameterName
self.helpString = "Edit " + parameterName + " (" + self.featureName + ")"
self.setLabelText(self.helpString + "\nCurrent Value = " + str(self.getValue()) + ": ")
self.setInputMode(1) #integer input only #make this modifiable
def showWindow(self):
self.resetLabel()
self.open()
def resetLabel(self):
self.setLabelText(self.helpString + " (Current Value = " + str(self.getValue()) + "): ")
def getValue(self):
return(self.intValue())
| {
"content_hash": "5d0c4640b4f6a410dd9b92b0c590d9af",
"timestamp": "",
"source": "github",
"line_count": 162,
"max_line_length": 163,
"avg_line_length": 38.58024691358025,
"alnum_prop": 0.70304,
"repo_name": "vnarayan13/Slicer-OpenCAD",
"id": "7b39afd50fd70b46cd2d7ef963752e86da8fa42a",
"size": "6250",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "HeterogeneityCAD/FeatureWidgetHelperLib/FeatureWidgets.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "CMake",
"bytes": "2870"
},
{
"name": "Python",
"bytes": "146475"
}
],
"symlink_target": ""
} |
"""This module provides some more Pythonic support for SSL.
Object types:
SSLSocket -- subtype of socket.socket which does SSL over the socket
Exceptions:
SSLError -- exception raised for I/O errors
Functions:
cert_time_to_seconds -- convert time string used for certificate
notBefore and notAfter functions to integer
seconds past the Epoch (the time values
returned from time.time())
fetch_server_certificate (HOST, PORT) -- fetch the certificate provided
by the server running on HOST at port PORT. No
validation of the certificate is performed.
Integer constants:
SSL_ERROR_ZERO_RETURN
SSL_ERROR_WANT_READ
SSL_ERROR_WANT_WRITE
SSL_ERROR_WANT_X509_LOOKUP
SSL_ERROR_SYSCALL
SSL_ERROR_SSL
SSL_ERROR_WANT_CONNECT
SSL_ERROR_EOF
SSL_ERROR_INVALID_ERROR_CODE
The following group define certificate requirements that one side is
allowing/requiring from the other side:
CERT_NONE - no certificates from the other side are required (or will
be looked at if provided)
CERT_OPTIONAL - certificates are not required, but if provided will be
validated, and if validation fails, the connection will
also fail
CERT_REQUIRED - certificates are required, and will be validated, and
if validation fails, the connection will also fail
The following constants identify various SSL protocol variants:
PROTOCOL_SSLv2
PROTOCOL_SSLv3
PROTOCOL_SSLv23
PROTOCOL_TLSv1
PROTOCOL_TLSv1_1
PROTOCOL_TLSv1_2
The following constants identify various SSL alert message descriptions as per
http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-6
ALERT_DESCRIPTION_CLOSE_NOTIFY
ALERT_DESCRIPTION_UNEXPECTED_MESSAGE
ALERT_DESCRIPTION_BAD_RECORD_MAC
ALERT_DESCRIPTION_RECORD_OVERFLOW
ALERT_DESCRIPTION_DECOMPRESSION_FAILURE
ALERT_DESCRIPTION_HANDSHAKE_FAILURE
ALERT_DESCRIPTION_BAD_CERTIFICATE
ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE
ALERT_DESCRIPTION_CERTIFICATE_REVOKED
ALERT_DESCRIPTION_CERTIFICATE_EXPIRED
ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN
ALERT_DESCRIPTION_ILLEGAL_PARAMETER
ALERT_DESCRIPTION_UNKNOWN_CA
ALERT_DESCRIPTION_ACCESS_DENIED
ALERT_DESCRIPTION_DECODE_ERROR
ALERT_DESCRIPTION_DECRYPT_ERROR
ALERT_DESCRIPTION_PROTOCOL_VERSION
ALERT_DESCRIPTION_INSUFFICIENT_SECURITY
ALERT_DESCRIPTION_INTERNAL_ERROR
ALERT_DESCRIPTION_USER_CANCELLED
ALERT_DESCRIPTION_NO_RENEGOTIATION
ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION
ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE
ALERT_DESCRIPTION_UNRECOGNIZED_NAME
ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE
ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE
ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY
"""
import textwrap
import re
import sys
import os
from collections import namedtuple
from contextlib import closing
import _ssl # if we can't import it, let the error propagate
from _ssl import OPENSSL_VERSION_NUMBER, OPENSSL_VERSION_INFO, OPENSSL_VERSION
from _ssl import _SSLContext
from _ssl import (
SSLError, SSLZeroReturnError, SSLWantReadError, SSLWantWriteError,
SSLSyscallError, SSLEOFError,
)
from _ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
from _ssl import txt2obj as _txt2obj, nid2obj as _nid2obj
from _ssl import RAND_status, RAND_add
try:
from _ssl import RAND_egd
except ImportError:
# LibreSSL does not provide RAND_egd
pass
def _import_symbols(prefix):
for n in dir(_ssl):
if n.startswith(prefix):
globals()[n] = getattr(_ssl, n)
_import_symbols('OP_')
_import_symbols('ALERT_DESCRIPTION_')
_import_symbols('SSL_ERROR_')
_import_symbols('PROTOCOL_')
_import_symbols('VERIFY_')
from _ssl import HAS_SNI, HAS_ECDH, HAS_NPN, HAS_ALPN
from _ssl import _OPENSSL_API_VERSION
_PROTOCOL_NAMES = {value: name for name, value in globals().items() if name.startswith('PROTOCOL_')}
try:
_SSLv2_IF_EXISTS = PROTOCOL_SSLv2
except NameError:
_SSLv2_IF_EXISTS = None
from socket import socket, _fileobject, _delegate_methods, error as socket_error
if sys.platform == "win32":
from _ssl import enum_certificates, enum_crls
from socket import socket, AF_INET, SOCK_STREAM, create_connection
from socket import SOL_SOCKET, SO_TYPE
import base64 # for DER-to-PEM translation
import errno
import warnings
if _ssl.HAS_TLS_UNIQUE:
CHANNEL_BINDING_TYPES = ['tls-unique']
else:
CHANNEL_BINDING_TYPES = []
# Disable weak or insecure ciphers by default
# (OpenSSL's default setting is 'DEFAULT:!aNULL:!eNULL')
# Enable a better set of ciphers by default
# This list has been explicitly chosen to:
# * Prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE)
# * Prefer ECDHE over DHE for better performance
# * Prefer any AES-GCM over any AES-CBC for better performance and security
# * Then Use HIGH cipher suites as a fallback
# * Then Use 3DES as fallback which is secure but slow
# * Disable NULL authentication, NULL encryption, and MD5 MACs for security
# reasons
_DEFAULT_CIPHERS = (
'ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+HIGH:'
'DH+HIGH:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+HIGH:RSA+3DES:!aNULL:'
'!eNULL:!MD5'
)
# Restricted and more secure ciphers for the server side
# This list has been explicitly chosen to:
# * Prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE)
# * Prefer ECDHE over DHE for better performance
# * Prefer any AES-GCM over any AES-CBC for better performance and security
# * Then Use HIGH cipher suites as a fallback
# * Then Use 3DES as fallback which is secure but slow
# * Disable NULL authentication, NULL encryption, MD5 MACs, DSS, and RC4 for
# security reasons
_RESTRICTED_SERVER_CIPHERS = (
'ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+HIGH:'
'DH+HIGH:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+HIGH:RSA+3DES:!aNULL:'
'!eNULL:!MD5:!DSS:!RC4'
)
class CertificateError(ValueError):
pass
def _dnsname_match(dn, hostname, max_wildcards=1):
"""Matching according to RFC 6125, section 6.4.3
http://tools.ietf.org/html/rfc6125#section-6.4.3
"""
pats = []
if not dn:
return False
pieces = dn.split(r'.')
leftmost = pieces[0]
remainder = pieces[1:]
wildcards = leftmost.count('*')
if wildcards > max_wildcards:
# Issue #17980: avoid denials of service by refusing more
# than one wildcard per fragment. A survery of established
# policy among SSL implementations showed it to be a
# reasonable choice.
raise CertificateError(
"too many wildcards in certificate DNS name: " + repr(dn))
# speed up common case w/o wildcards
if not wildcards:
return dn.lower() == hostname.lower()
# RFC 6125, section 6.4.3, subitem 1.
# The client SHOULD NOT attempt to match a presented identifier in which
# the wildcard character comprises a label other than the left-most label.
if leftmost == '*':
# When '*' is a fragment by itself, it matches a non-empty dotless
# fragment.
pats.append('[^.]+')
elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
# RFC 6125, section 6.4.3, subitem 3.
# The client SHOULD NOT attempt to match a presented identifier
# where the wildcard character is embedded within an A-label or
# U-label of an internationalized domain name.
pats.append(re.escape(leftmost))
else:
# Otherwise, '*' matches any dotless string, e.g. www*
pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
# add the remaining fragments, ignore any wildcards
for frag in remainder:
pats.append(re.escape(frag))
pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
return pat.match(hostname)
def match_hostname(cert, hostname):
"""Verify that *cert* (in decoded format as returned by
SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125
rules are followed, but IP addresses are not accepted for *hostname*.
CertificateError is raised on failure. On success, the function
returns nothing.
"""
if not cert:
raise ValueError("empty or no certificate, match_hostname needs a "
"SSL socket or SSL context with either "
"CERT_OPTIONAL or CERT_REQUIRED")
dnsnames = []
san = cert.get('subjectAltName', ())
for key, value in san:
if key == 'DNS':
if _dnsname_match(value, hostname):
return
dnsnames.append(value)
if not dnsnames:
# The subject is only checked when there is no dNSName entry
# in subjectAltName
for sub in cert.get('subject', ()):
for key, value in sub:
# XXX according to RFC 2818, the most specific Common Name
# must be used.
if key == 'commonName':
if _dnsname_match(value, hostname):
return
dnsnames.append(value)
if len(dnsnames) > 1:
raise CertificateError("hostname %r "
"doesn't match either of %s"
% (hostname, ', '.join(map(repr, dnsnames))))
elif len(dnsnames) == 1:
raise CertificateError("hostname %r "
"doesn't match %r"
% (hostname, dnsnames[0]))
else:
raise CertificateError("no appropriate commonName or "
"subjectAltName fields were found")
DefaultVerifyPaths = namedtuple("DefaultVerifyPaths",
"cafile capath openssl_cafile_env openssl_cafile openssl_capath_env "
"openssl_capath")
def get_default_verify_paths():
"""Return paths to default cafile and capath.
"""
parts = _ssl.get_default_verify_paths()
# environment vars shadow paths
cafile = os.environ.get(parts[0], parts[1])
capath = os.environ.get(parts[2], parts[3])
return DefaultVerifyPaths(cafile if os.path.isfile(cafile) else None,
capath if os.path.isdir(capath) else None,
*parts)
class _ASN1Object(namedtuple("_ASN1Object", "nid shortname longname oid")):
"""ASN.1 object identifier lookup
"""
__slots__ = ()
def __new__(cls, oid):
return super(_ASN1Object, cls).__new__(cls, *_txt2obj(oid, name=False))
@classmethod
def fromnid(cls, nid):
"""Create _ASN1Object from OpenSSL numeric ID
"""
return super(_ASN1Object, cls).__new__(cls, *_nid2obj(nid))
@classmethod
def fromname(cls, name):
"""Create _ASN1Object from short name, long name or OID
"""
return super(_ASN1Object, cls).__new__(cls, *_txt2obj(name, name=True))
class Purpose(_ASN1Object):
"""SSLContext purpose flags with X509v3 Extended Key Usage objects
"""
Purpose.SERVER_AUTH = Purpose('1.3.6.1.5.5.7.3.1')
Purpose.CLIENT_AUTH = Purpose('1.3.6.1.5.5.7.3.2')
class SSLContext(_SSLContext):
"""An SSLContext holds various SSL-related configuration options and
data, such as certificates and possibly a private key."""
__slots__ = ('protocol', '__weakref__')
_windows_cert_stores = ("CA", "ROOT")
def __new__(cls, protocol, *args, **kwargs):
self = _SSLContext.__new__(cls, protocol)
if protocol != _SSLv2_IF_EXISTS:
self.set_ciphers(_DEFAULT_CIPHERS)
return self
def __init__(self, protocol):
self.protocol = protocol
def wrap_socket(self, sock, server_side=False,
do_handshake_on_connect=True,
suppress_ragged_eofs=True,
server_hostname=None):
return SSLSocket(sock=sock, server_side=server_side,
do_handshake_on_connect=do_handshake_on_connect,
suppress_ragged_eofs=suppress_ragged_eofs,
server_hostname=server_hostname,
_context=self)
def set_npn_protocols(self, npn_protocols):
protos = bytearray()
for protocol in npn_protocols:
b = protocol.encode('ascii')
if len(b) == 0 or len(b) > 255:
raise SSLError('NPN protocols must be 1 to 255 in length')
protos.append(len(b))
protos.extend(b)
self._set_npn_protocols(protos)
def set_alpn_protocols(self, alpn_protocols):
protos = bytearray()
for protocol in alpn_protocols:
b = protocol.encode('ascii')
if len(b) == 0 or len(b) > 255:
raise SSLError('ALPN protocols must be 1 to 255 in length')
protos.append(len(b))
protos.extend(b)
self._set_alpn_protocols(protos)
def _load_windows_store_certs(self, storename, purpose):
certs = bytearray()
try:
for cert, encoding, trust in enum_certificates(storename):
# CA certs are never PKCS#7 encoded
if encoding == "x509_asn":
if trust is True or purpose.oid in trust:
certs.extend(cert)
except OSError:
warnings.warn("unable to enumerate Windows certificate store")
if certs:
self.load_verify_locations(cadata=certs)
return certs
def load_default_certs(self, purpose=Purpose.SERVER_AUTH):
if not isinstance(purpose, _ASN1Object):
raise TypeError(purpose)
if sys.platform == "win32":
for storename in self._windows_cert_stores:
self._load_windows_store_certs(storename, purpose)
self.set_default_verify_paths()
def create_default_context(purpose=Purpose.SERVER_AUTH, cafile=None,
capath=None, cadata=None):
"""Create a SSLContext object with default settings.
NOTE: The protocol and settings may change anytime without prior
deprecation. The values represent a fair balance between maximum
compatibility and security.
"""
if not isinstance(purpose, _ASN1Object):
raise TypeError(purpose)
context = SSLContext(PROTOCOL_SSLv23)
# SSLv2 considered harmful.
context.options |= OP_NO_SSLv2
# SSLv3 has problematic security and is only required for really old
# clients such as IE6 on Windows XP
context.options |= OP_NO_SSLv3
# disable compression to prevent CRIME attacks (OpenSSL 1.0+)
context.options |= getattr(_ssl, "OP_NO_COMPRESSION", 0)
if purpose == Purpose.SERVER_AUTH:
# verify certs and host name in client mode
context.verify_mode = CERT_REQUIRED
context.check_hostname = True
elif purpose == Purpose.CLIENT_AUTH:
# Prefer the server's ciphers by default so that we get stronger
# encryption
context.options |= getattr(_ssl, "OP_CIPHER_SERVER_PREFERENCE", 0)
# Use single use keys in order to improve forward secrecy
context.options |= getattr(_ssl, "OP_SINGLE_DH_USE", 0)
context.options |= getattr(_ssl, "OP_SINGLE_ECDH_USE", 0)
# disallow ciphers with known vulnerabilities
context.set_ciphers(_RESTRICTED_SERVER_CIPHERS)
if cafile or capath or cadata:
context.load_verify_locations(cafile, capath, cadata)
elif context.verify_mode != CERT_NONE:
# no explicit cafile, capath or cadata but the verify mode is
# CERT_OPTIONAL or CERT_REQUIRED. Let's try to load default system
# root CA certificates for the given purpose. This may fail silently.
context.load_default_certs(purpose)
return context
def _create_unverified_context(protocol=PROTOCOL_SSLv23, cert_reqs=None,
check_hostname=False, purpose=Purpose.SERVER_AUTH,
certfile=None, keyfile=None,
cafile=None, capath=None, cadata=None):
"""Create a SSLContext object for Python stdlib modules
All Python stdlib modules shall use this function to create SSLContext
objects in order to keep common settings in one place. The configuration
is less restrict than create_default_context()'s to increase backward
compatibility.
"""
if not isinstance(purpose, _ASN1Object):
raise TypeError(purpose)
context = SSLContext(protocol)
# SSLv2 considered harmful.
context.options |= OP_NO_SSLv2
# SSLv3 has problematic security and is only required for really old
# clients such as IE6 on Windows XP
context.options |= OP_NO_SSLv3
if cert_reqs is not None:
context.verify_mode = cert_reqs
context.check_hostname = check_hostname
if keyfile and not certfile:
raise ValueError("certfile must be specified")
if certfile or keyfile:
context.load_cert_chain(certfile, keyfile)
# load CA root certs
if cafile or capath or cadata:
context.load_verify_locations(cafile, capath, cadata)
elif context.verify_mode != CERT_NONE:
# no explicit cafile, capath or cadata but the verify mode is
# CERT_OPTIONAL or CERT_REQUIRED. Let's try to load default system
# root CA certificates for the given purpose. This may fail silently.
context.load_default_certs(purpose)
return context
# Backwards compatibility alias, even though it's not a public name.
_create_stdlib_context = _create_unverified_context
# PEP 493: Verify HTTPS by default, but allow envvar to override that
_https_verify_envvar = 'PYTHONHTTPSVERIFY'
def _get_https_context_factory():
if not sys.flags.ignore_environment:
config_setting = os.environ.get(_https_verify_envvar)
if config_setting == '0':
return _create_unverified_context
return create_default_context
_create_default_https_context = _get_https_context_factory()
# PEP 493: "private" API to configure HTTPS defaults without monkeypatching
def _https_verify_certificates(enable=True):
"""Verify server HTTPS certificates by default?"""
global _create_default_https_context
if enable:
_create_default_https_context = create_default_context
else:
_create_default_https_context = _create_unverified_context
class SSLSocket(socket):
"""This class implements a subtype of socket.socket that wraps
the underlying OS socket in an SSL context when necessary, and
provides read and write methods over that channel."""
def __init__(self, sock=None, keyfile=None, certfile=None,
server_side=False, cert_reqs=CERT_NONE,
ssl_version=PROTOCOL_SSLv23, ca_certs=None,
do_handshake_on_connect=True,
family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None,
suppress_ragged_eofs=True, npn_protocols=None, ciphers=None,
server_hostname=None,
_context=None):
self._makefile_refs = 0
if _context:
self._context = _context
else:
if server_side and not certfile:
raise ValueError("certfile must be specified for server-side "
"operations")
if keyfile and not certfile:
raise ValueError("certfile must be specified")
if certfile and not keyfile:
keyfile = certfile
self._context = SSLContext(ssl_version)
self._context.verify_mode = cert_reqs
if ca_certs:
self._context.load_verify_locations(ca_certs)
if certfile:
self._context.load_cert_chain(certfile, keyfile)
if npn_protocols:
self._context.set_npn_protocols(npn_protocols)
if ciphers:
self._context.set_ciphers(ciphers)
self.keyfile = keyfile
self.certfile = certfile
self.cert_reqs = cert_reqs
self.ssl_version = ssl_version
self.ca_certs = ca_certs
self.ciphers = ciphers
# Can't use sock.type as other flags (such as SOCK_NONBLOCK) get
# mixed in.
if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM:
raise NotImplementedError("only stream sockets are supported")
socket.__init__(self, _sock=sock._sock)
# The initializer for socket overrides the methods send(), recv(), etc.
# in the instancce, which we don't need -- but we want to provide the
# methods defined in SSLSocket.
for attr in _delegate_methods:
try:
delattr(self, attr)
except AttributeError:
pass
if server_side and server_hostname:
raise ValueError("server_hostname can only be specified "
"in client mode")
if self._context.check_hostname and not server_hostname:
raise ValueError("check_hostname requires server_hostname")
self.server_side = server_side
self.server_hostname = server_hostname
self.do_handshake_on_connect = do_handshake_on_connect
self.suppress_ragged_eofs = suppress_ragged_eofs
# See if we are connected
try:
self.getpeername()
except socket_error as e:
if e.errno != errno.ENOTCONN:
raise
connected = False
else:
connected = True
self._closed = False
self._sslobj = None
self._connected = connected
if connected:
# create the SSL object
try:
self._sslobj = self._context._wrap_socket(self._sock, server_side,
server_hostname, ssl_sock=self)
if do_handshake_on_connect:
timeout = self.gettimeout()
if timeout == 0.0:
# non-blocking
raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets")
self.do_handshake()
except (OSError, ValueError):
self.close()
raise
@property
def context(self):
return self._context
@context.setter
def context(self, ctx):
self._context = ctx
self._sslobj.context = ctx
def dup(self):
raise NotImplemented("Can't dup() %s instances" %
self.__class__.__name__)
def _checkClosed(self, msg=None):
# raise an exception here if you wish to check for spurious closes
pass
def _check_connected(self):
if not self._connected:
# getpeername() will raise ENOTCONN if the socket is really
# not connected; note that we can be connected even without
# _connected being set, e.g. if connect() first returned
# EAGAIN.
self.getpeername()
def read(self, len=1024, buffer=None):
"""Read up to LEN bytes and return them.
Return zero-length string on EOF."""
self._checkClosed()
if not self._sslobj:
raise ValueError("Read on closed or unwrapped SSL socket.")
try:
if buffer is not None:
v = self._sslobj.read(len, buffer)
else:
v = self._sslobj.read(len)
return v
except SSLError as x:
if x.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs:
if buffer is not None:
return 0
else:
return b''
else:
raise
def write(self, data):
"""Write DATA to the underlying SSL channel. Returns
number of bytes of DATA actually transmitted."""
self._checkClosed()
if not self._sslobj:
raise ValueError("Write on closed or unwrapped SSL socket.")
return self._sslobj.write(data)
def getpeercert(self, binary_form=False):
"""Returns a formatted version of the data in the
certificate provided by the other end of the SSL channel.
Return None if no certificate was provided, {} if a
certificate was provided, but not validated."""
self._checkClosed()
self._check_connected()
return self._sslobj.peer_certificate(binary_form)
def selected_npn_protocol(self):
self._checkClosed()
if not self._sslobj or not _ssl.HAS_NPN:
return None
else:
return self._sslobj.selected_npn_protocol()
def selected_alpn_protocol(self):
self._checkClosed()
if not self._sslobj or not _ssl.HAS_ALPN:
return None
else:
return self._sslobj.selected_alpn_protocol()
def cipher(self):
self._checkClosed()
if not self._sslobj:
return None
else:
return self._sslobj.cipher()
def compression(self):
self._checkClosed()
if not self._sslobj:
return None
else:
return self._sslobj.compression()
def send(self, data, flags=0):
self._checkClosed()
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to send() on %s" %
self.__class__)
try:
v = self._sslobj.write(data)
except SSLError as x:
if x.args[0] == SSL_ERROR_WANT_READ:
return 0
elif x.args[0] == SSL_ERROR_WANT_WRITE:
return 0
else:
raise
else:
return v
else:
return self._sock.send(data, flags)
def sendto(self, data, flags_or_addr, addr=None):
self._checkClosed()
if self._sslobj:
raise ValueError("sendto not allowed on instances of %s" %
self.__class__)
elif addr is None:
return self._sock.sendto(data, flags_or_addr)
else:
return self._sock.sendto(data, flags_or_addr, addr)
def sendall(self, data, flags=0):
self._checkClosed()
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to sendall() on %s" %
self.__class__)
amount = len(data)
count = 0
while (count < amount):
v = self.send(data[count:])
count += v
return amount
else:
return socket.sendall(self, data, flags)
def recv(self, buflen=1024, flags=0):
self._checkClosed()
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to recv() on %s" %
self.__class__)
return self.read(buflen)
else:
return self._sock.recv(buflen, flags)
def recv_into(self, buffer, nbytes=None, flags=0):
self._checkClosed()
if buffer and (nbytes is None):
nbytes = len(buffer)
elif nbytes is None:
nbytes = 1024
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to recv_into() on %s" %
self.__class__)
return self.read(nbytes, buffer)
else:
return self._sock.recv_into(buffer, nbytes, flags)
def recvfrom(self, buflen=1024, flags=0):
self._checkClosed()
if self._sslobj:
raise ValueError("recvfrom not allowed on instances of %s" %
self.__class__)
else:
return self._sock.recvfrom(buflen, flags)
def recvfrom_into(self, buffer, nbytes=None, flags=0):
self._checkClosed()
if self._sslobj:
raise ValueError("recvfrom_into not allowed on instances of %s" %
self.__class__)
else:
return self._sock.recvfrom_into(buffer, nbytes, flags)
def pending(self):
self._checkClosed()
if self._sslobj:
return self._sslobj.pending()
else:
return 0
def shutdown(self, how):
self._checkClosed()
self._sslobj = None
socket.shutdown(self, how)
def close(self):
if self._makefile_refs < 1:
self._sslobj = None
socket.close(self)
else:
self._makefile_refs -= 1
def unwrap(self):
if self._sslobj:
s = self._sslobj.shutdown()
self._sslobj = None
return s
else:
raise ValueError("No SSL wrapper around " + str(self))
def _real_close(self):
self._sslobj = None
socket._real_close(self)
def do_handshake(self, block=False):
"""Perform a TLS/SSL handshake."""
self._check_connected()
timeout = self.gettimeout()
try:
if timeout == 0.0 and block:
self.settimeout(None)
self._sslobj.do_handshake()
finally:
self.settimeout(timeout)
if self.context.check_hostname:
if not self.server_hostname:
raise ValueError("check_hostname needs server_hostname "
"argument")
match_hostname(self.getpeercert(), self.server_hostname)
def _real_connect(self, addr, connect_ex):
if self.server_side:
raise ValueError("can't connect in server-side mode")
# Here we assume that the socket is client-side, and not
# connected at the time of the call. We connect it, then wrap it.
if self._connected:
raise ValueError("attempt to connect already-connected SSLSocket!")
self._sslobj = self.context._wrap_socket(self._sock, False, self.server_hostname, ssl_sock=self)
try:
if connect_ex:
rc = socket.connect_ex(self, addr)
else:
rc = None
socket.connect(self, addr)
if not rc:
self._connected = True
if self.do_handshake_on_connect:
self.do_handshake()
return rc
except (OSError, ValueError):
self._sslobj = None
raise
def connect(self, addr):
"""Connects to remote ADDR, and then wraps the connection in
an SSL channel."""
self._real_connect(addr, False)
def connect_ex(self, addr):
"""Connects to remote ADDR, and then wraps the connection in
an SSL channel."""
return self._real_connect(addr, True)
def accept(self):
"""Accepts a new connection from a remote client, and returns
a tuple containing that new connection wrapped with a server-side
SSL channel, and the address of the remote client."""
newsock, addr = socket.accept(self)
newsock = self.context.wrap_socket(newsock,
do_handshake_on_connect=self.do_handshake_on_connect,
suppress_ragged_eofs=self.suppress_ragged_eofs,
server_side=True)
return newsock, addr
def makefile(self, mode='r', bufsize=-1):
"""Make and return a file-like object that
works with the SSL connection. Just use the code
from the socket module."""
self._makefile_refs += 1
# close=True so as to decrement the reference count when done with
# the file-like object.
return _fileobject(self, mode, bufsize, close=True)
def get_channel_binding(self, cb_type="tls-unique"):
"""Get channel binding data for current connection. Raise ValueError
if the requested `cb_type` is not supported. Return bytes of the data
or None if the data is not available (e.g. before the handshake).
"""
if cb_type not in CHANNEL_BINDING_TYPES:
raise ValueError("Unsupported channel binding type")
if cb_type != "tls-unique":
raise NotImplementedError(
"{0} channel binding type not implemented"
.format(cb_type))
if self._sslobj is None:
return None
return self._sslobj.tls_unique_cb()
def version(self):
"""
Return a string identifying the protocol version used by the
current SSL channel, or None if there is no established channel.
"""
if self._sslobj is None:
return None
return self._sslobj.version()
def wrap_socket(sock, keyfile=None, certfile=None,
server_side=False, cert_reqs=CERT_NONE,
ssl_version=PROTOCOL_SSLv23, ca_certs=None,
do_handshake_on_connect=True,
suppress_ragged_eofs=True,
ciphers=None):
return SSLSocket(sock=sock, keyfile=keyfile, certfile=certfile,
server_side=server_side, cert_reqs=cert_reqs,
ssl_version=ssl_version, ca_certs=ca_certs,
do_handshake_on_connect=do_handshake_on_connect,
suppress_ragged_eofs=suppress_ragged_eofs,
ciphers=ciphers)
# some utility functions
def cert_time_to_seconds(cert_time):
"""Return the time in seconds since the Epoch, given the timestring
representing the "notBefore" or "notAfter" date from a certificate
in ``"%b %d %H:%M:%S %Y %Z"`` strptime format (C locale).
"notBefore" or "notAfter" dates must use UTC (RFC 5280).
Month is one of: Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
UTC should be specified as GMT (see ASN1_TIME_print())
"""
from time import strptime
from calendar import timegm
months = (
"Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"
)
time_format = ' %d %H:%M:%S %Y GMT' # NOTE: no month, fixed GMT
try:
month_number = months.index(cert_time[:3].title()) + 1
except ValueError:
raise ValueError('time data %r does not match '
'format "%%b%s"' % (cert_time, time_format))
else:
# found valid month
tt = strptime(cert_time[3:], time_format)
# return an integer, the previous mktime()-based implementation
# returned a float (fractional seconds are always zero here).
return timegm((tt[0], month_number) + tt[2:6])
PEM_HEADER = "-----BEGIN CERTIFICATE-----"
PEM_FOOTER = "-----END CERTIFICATE-----"
def DER_cert_to_PEM_cert(der_cert_bytes):
"""Takes a certificate in binary DER format and returns the
PEM version of it as a string."""
f = base64.standard_b64encode(der_cert_bytes).decode('ascii')
return (PEM_HEADER + '\n' +
textwrap.fill(f, 64) + '\n' +
PEM_FOOTER + '\n')
def PEM_cert_to_DER_cert(pem_cert_string):
"""Takes a certificate in ASCII PEM format and returns the
DER-encoded version of it as a byte sequence"""
if not pem_cert_string.startswith(PEM_HEADER):
raise ValueError("Invalid PEM encoding; must start with %s"
% PEM_HEADER)
if not pem_cert_string.strip().endswith(PEM_FOOTER):
raise ValueError("Invalid PEM encoding; must end with %s"
% PEM_FOOTER)
d = pem_cert_string.strip()[len(PEM_HEADER):-len(PEM_FOOTER)]
return base64.decodestring(d.encode('ASCII', 'strict'))
def get_server_certificate(addr, ssl_version=PROTOCOL_SSLv23, ca_certs=None):
"""Retrieve the certificate from the server at the specified address,
and return it as a PEM-encoded string.
If 'ca_certs' is specified, validate the server cert against it.
If 'ssl_version' is specified, use it in the connection attempt."""
host, port = addr
if ca_certs is not None:
cert_reqs = CERT_REQUIRED
else:
cert_reqs = CERT_NONE
context = _create_stdlib_context(ssl_version,
cert_reqs=cert_reqs,
cafile=ca_certs)
with closing(create_connection(addr)) as sock:
with closing(context.wrap_socket(sock)) as sslsock:
dercert = sslsock.getpeercert(True)
return DER_cert_to_PEM_cert(dercert)
def get_protocol_name(protocol_code):
return _PROTOCOL_NAMES.get(protocol_code, '<unknown>')
# a replacement for the old socket.ssl function
def sslwrap_simple(sock, keyfile=None, certfile=None):
"""A replacement for the old socket.ssl function. Designed
for compability with Python 2.5 and earlier. Will disappear in
Python 3.0."""
if hasattr(sock, "_sock"):
sock = sock._sock
ctx = SSLContext(PROTOCOL_SSLv23)
if keyfile or certfile:
ctx.load_cert_chain(certfile, keyfile)
ssl_sock = ctx._wrap_socket(sock, server_side=False)
try:
sock.getpeername()
except socket_error:
# no, no connection yet
pass
else:
# yes, do the handshake
ssl_sock.do_handshake()
return ssl_sock
| {
"content_hash": "1831a4641dfc50fd1fadcfb45a24b397",
"timestamp": "",
"source": "github",
"line_count": 1034,
"max_line_length": 116,
"avg_line_length": 36.09090909090909,
"alnum_prop": 0.6124926309019776,
"repo_name": "franekp/millandict",
"id": "60703808793345f08ad3f4b71b61a47bba837ce4",
"size": "37434",
"binary": false,
"copies": "10",
"ref": "refs/heads/master",
"path": "ankidict/thirdparty/ssl.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "C++",
"bytes": "913"
},
{
"name": "CSS",
"bytes": "1117"
},
{
"name": "Python",
"bytes": "86639"
},
{
"name": "QMake",
"bytes": "158"
},
{
"name": "VimL",
"bytes": "31"
}
],
"symlink_target": ""
} |
from __future__ import print_function
from numpy import pi, arange, sin
import numpy as np
import time
from bokeh.browserlib import view
from bokeh.document import Document
from bokeh.embed import file_html
from bokeh.glyphs import Circle
from bokeh.objects import (
Plot, DataRange1d, DatetimeAxis,
ColumnDataSource, PanTool, WheelZoomTool
)
from bokeh.resources import INLINE
x = arange(-2 * pi, 2 * pi, 0.1)
y = sin(x)
# Create an array of times, starting at the current time, and extending
# for len(x) number of hours.
times = np.arange(len(x)) * 3600000 + time.time()
source = ColumnDataSource(
data=dict(x=x, y=y, times=times)
)
xdr = DataRange1d(sources=[source.columns("times")])
ydr = DataRange1d(sources=[source.columns("y")])
plot = Plot(x_range=xdr, y_range=ydr, min_border=80)
circle = Circle(x="times", y="y", fill_color="red", size=5, line_color="black")
plot.add_glyph(source, circle)
plot.add_layout(DatetimeAxis(), 'below')
plot.add_layout(DatetimeAxis(), 'left')
plot.add_tools(PanTool(), WheelZoomTool())
doc = Document()
doc.add(plot)
if __name__ == "__main__":
filename = "dateaxis.html"
with open(filename, "w") as f:
f.write(file_html(doc, INLINE, "Date Axis Example"))
print("Wrote %s" % filename)
view(filename)
| {
"content_hash": "7a73c61087ce9ae6f66480c854ae96bb",
"timestamp": "",
"source": "github",
"line_count": 49,
"max_line_length": 79,
"avg_line_length": 26.26530612244898,
"alnum_prop": 0.6985236985236986,
"repo_name": "jakevdp/bokeh",
"id": "30132385802ae5f0c02e2c34fb856423422f4476",
"size": "1287",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "examples/glyphs/dateaxis.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [],
"symlink_target": ""
} |
"""Create pidstore branch."""
import sqlalchemy as sa
from alembic import op
# revision identifiers, used by Alembic.
revision = "f615cee99600"
down_revision = None
branch_labels = ("invenio_pidstore",)
depends_on = "dbdbc1b19cf2"
def upgrade():
"""Upgrade database."""
def downgrade():
"""Downgrade database."""
| {
"content_hash": "488ccc909e6a78d57417828841ef7f0e",
"timestamp": "",
"source": "github",
"line_count": 18,
"max_line_length": 40,
"avg_line_length": 18.166666666666668,
"alnum_prop": 0.7003058103975535,
"repo_name": "inveniosoftware/invenio-pidstore",
"id": "500943ad5553fc16af108949cca820b79db84e19",
"size": "562",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "invenio_pidstore/alembic/f615cee99600_create_pidstore_branch.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "126932"
},
{
"name": "Shell",
"bytes": "839"
}
],
"symlink_target": ""
} |
from __future__ import print_function
from optparse import OptionParser
from os import path
import pipes
from sys import stderr
from util import check_output
def mvn(action):
return ['mvn', '--file', path.join(root, 'fake_pom_%s.xml' % action)]
def mvn(action):
return ['mvn', '--file', path.join(root, 'fake_pom_%s.xml' % action)]
opts = OptionParser()
opts.add_option('--repository', help='maven repository id')
opts.add_option('--url', help='maven repository url')
opts.add_option('-o')
opts.add_option('-g', help='maven group id')
opts.add_option('-a', help='action (valid actions are: install,deploy)')
opts.add_option('-v', help='package version')
opts.add_option('-s', action='append', help='triplet of artifactId:type:path')
args, ctx = opts.parse_args()
if not args.g:
print('group is empty', file=stderr)
exit(1)
if not args.v:
print('version is empty', file=stderr)
exit(1)
common = [
'-DgroupId=%s' % args.g,
'-Dversion=%s' % args.v,
]
root = path.abspath(__file__)
while not path.exists(path.join(root, '.buckconfig')):
root = path.dirname(root)
if 'install' == args.a:
cmd = mvn(args.a) + ['install:install-file'] + common
elif 'deploy' == args.a:
cmd = mvn(args.a) + [
'deploy:deploy-file',
'-DrepositoryId=%s' % args.repository,
'-Durl=%s' % args.url,
] + common
else:
print("unknown action -a %s" % args.a, file=stderr)
exit(1)
for spec in args.s:
artifact, packaging_type, src = spec.split(':')
cmds = cmd + [
'-DartifactId=%s' % artifact,
'-Dpackaging=%s' % packaging_type,
'-Dfile=%s' % src,
]
try:
check_output(cmds)
except Exception as e:
cmds_str = ' '.join(pipes.quote(c) for c in cmds)
print("%s command failed: `%s`: %s" % (args.a, cmds_str, e), file=stderr)
exit(1)
with open(args.o, 'w') as fd:
if args.repository:
print('Repository: %s' % args.repository, file=fd)
if args.url:
print('URL: %s' % args.url, file=fd)
print('Version: %s' % args.v, file=fd)
| {
"content_hash": "dfc55a842d699cc13aba4d806fb4f254",
"timestamp": "",
"source": "github",
"line_count": 72,
"max_line_length": 78,
"avg_line_length": 27.569444444444443,
"alnum_prop": 0.6392947103274559,
"repo_name": "JulienGenoud/gitiles",
"id": "107db609da7a5b0f546758f5420e5b55005e5924",
"size": "2599",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "bucklets/tools/mvn.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "CSS",
"bytes": "16459"
},
{
"name": "Java",
"bytes": "556704"
},
{
"name": "Python",
"bytes": "17149"
}
],
"symlink_target": ""
} |
"""Test BIP65 (CHECKLOCKTIMEVERIFY).
Test that the CHECKLOCKTIMEVERIFY soft-fork activates at (regtest) block height
1351.
"""
from test_framework.blocktools import create_coinbase, create_block, create_transaction
from test_framework.messages import CTransaction, msg_block, ToHex
from test_framework.p2p import P2PInterface
from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP, CScriptNum
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import (
assert_equal,
hex_str_to_bytes,
)
from io import BytesIO
CLTV_HEIGHT = 1351
VB_TOP_BITS = 0x20000000
def cltv_invalidate(tx):
'''Modify the signature in vin 0 of the tx to fail CLTV
Prepends -1 CLTV DROP in the scriptSig itself.
TODO: test more ways that transactions using CLTV could be invalid (eg
locktime requirements fail, sequence time requirements fail, etc).
'''
tx.vin[0].scriptSig = CScript([OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP] +
list(CScript(tx.vin[0].scriptSig)))
def cltv_validate(node, tx, height):
'''Modify the signature in vin 0 of the tx to pass CLTV
Prepends <height> CLTV DROP in the scriptSig, and sets
the locktime to height'''
tx.vin[0].nSequence = 0
tx.nLockTime = height
# Need to re-sign, since nSequence and nLockTime changed
signed_result = node.signrawtransactionwithwallet(ToHex(tx))
new_tx = CTransaction()
new_tx.deserialize(BytesIO(hex_str_to_bytes(signed_result['hex'])))
new_tx.vin[0].scriptSig = CScript([CScriptNum(height), OP_CHECKLOCKTIMEVERIFY, OP_DROP] +
list(CScript(new_tx.vin[0].scriptSig)))
return new_tx
class BIP65Test(BitcoinTestFramework):
def set_test_params(self):
self.num_nodes = 1
self.extra_args = [[
'[email protected]',
'-par=1', # Use only one script thread to get the exact reject reason for testing
'-acceptnonstdtxn=1', # cltv_invalidate is nonstandard
'-vbparams=mweb:-2:0',
]]
self.setup_clean_chain = True
self.rpc_timeout = 480
def skip_test_if_missing_module(self):
self.skip_if_no_wallet()
def test_cltv_info(self, *, is_active):
assert_equal(self.nodes[0].getblockchaininfo()['softforks']['bip65'],
{
"active": is_active,
"height": CLTV_HEIGHT,
"type": "buried",
},
)
def run_test(self):
peer = self.nodes[0].add_p2p_connection(P2PInterface())
self.test_cltv_info(is_active=False)
self.log.info("Mining %d blocks", CLTV_HEIGHT - 2)
self.coinbase_txids = [self.nodes[0].getblock(b)['tx'][0] for b in self.nodes[0].generate(CLTV_HEIGHT - 2)]
self.nodeaddress = self.nodes[0].getnewaddress()
self.log.info("Test that an invalid-according-to-CLTV transaction can still appear in a block")
spendtx = create_transaction(self.nodes[0], self.coinbase_txids[0],
self.nodeaddress, amount=1.0)
cltv_invalidate(spendtx)
spendtx.rehash()
tip = self.nodes[0].getbestblockhash()
block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
block = create_block(int(tip, 16), create_coinbase(CLTV_HEIGHT - 1), block_time)
block.nVersion = VB_TOP_BITS
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.solve()
self.test_cltv_info(is_active=False) # Not active as of current tip and next block does not need to obey rules
peer.send_and_ping(msg_block(block))
self.test_cltv_info(is_active=True) # Not active as of current tip, but next block must obey rules
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
self.log.info("Test that blocks must now be at least version VB_TOP_BITS")
tip = block.sha256
block_time += 1
block = create_block(tip, create_coinbase(CLTV_HEIGHT), block_time)
block.nVersion = 3
block.solve()
with self.nodes[0].assert_debug_log(expected_msgs=['{}, bad-version(0x00000003)'.format(block.hash)]):
peer.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
peer.sync_with_ping()
self.log.info("Test that invalid-according-to-cltv transactions cannot appear in a block")
block.nVersion = VB_TOP_BITS
spendtx = create_transaction(self.nodes[0], self.coinbase_txids[1],
self.nodeaddress, amount=1.0)
cltv_invalidate(spendtx)
spendtx.rehash()
# First we show that this tx is valid except for CLTV by getting it
# rejected from the mempool for exactly that reason.
assert_equal(
[{'txid': spendtx.hash, 'allowed': False, 'reject-reason': 'non-mandatory-script-verify-flag (Negative locktime)'}],
self.nodes[0].testmempoolaccept(rawtxs=[spendtx.serialize().hex()], maxfeerate=0)
)
# Now we verify that a block with this transaction is also invalid.
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.solve()
with self.nodes[0].assert_debug_log(expected_msgs=['CheckInputScripts on {} failed with non-mandatory-script-verify-flag (Negative locktime)'.format(block.vtx[-1].hash)]):
peer.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
peer.sync_with_ping()
self.log.info("Test that a version VB_TOP_BITS block with a valid-according-to-CLTV transaction is accepted")
spendtx = cltv_validate(self.nodes[0], spendtx, CLTV_HEIGHT - 1)
spendtx.rehash()
block.vtx.pop(1)
block.vtx.append(spendtx)
block.hashMerkleRoot = block.calc_merkle_root()
block.solve()
self.test_cltv_info(is_active=True) # Not active as of current tip, but next block must obey rules
peer.send_and_ping(msg_block(block))
self.test_cltv_info(is_active=True) # Active as of current tip
assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)
if __name__ == '__main__':
BIP65Test().main()
| {
"content_hash": "840a79612debd108f09db18969da36a4",
"timestamp": "",
"source": "github",
"line_count": 156,
"max_line_length": 179,
"avg_line_length": 40.782051282051285,
"alnum_prop": 0.6468091795033009,
"repo_name": "litecoin-project/litecoin",
"id": "07ee6e61e28fcde478ebf240118cb66e9d372e8b",
"size": "6576",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "test/functional/feature_cltv.py",
"mode": "33261",
"license": "mit",
"language": [
{
"name": "Assembly",
"bytes": "898000"
},
{
"name": "C",
"bytes": "1594708"
},
{
"name": "C++",
"bytes": "8860047"
},
{
"name": "CMake",
"bytes": "29310"
},
{
"name": "HTML",
"bytes": "21833"
},
{
"name": "Java",
"bytes": "30291"
},
{
"name": "M4",
"bytes": "226003"
},
{
"name": "Makefile",
"bytes": "123607"
},
{
"name": "Objective-C++",
"bytes": "5489"
},
{
"name": "Python",
"bytes": "2267056"
},
{
"name": "QMake",
"bytes": "798"
},
{
"name": "Sage",
"bytes": "31382"
},
{
"name": "Scheme",
"bytes": "7554"
},
{
"name": "Shell",
"bytes": "150309"
}
],
"symlink_target": ""
} |
from oslo_log import log as logging
from f5_openstack_agent.lbaasv2.drivers.bigip import resource_helper
from f5_openstack_agent.lbaasv2.drivers.bigip import ssl_profile
from requests import HTTPError
from f5_openstack_agent.lbaasv2.drivers.bigip import exceptions as f5_ex
LOG = logging.getLogger(__name__)
class ListenerServiceBuilder(object):
u"""Create LBaaS v2 Listener on BIG-IPs.
Handles requests to create, update, delete LBaaS v2 listener
objects on one or more BIG-IP systems. Maps LBaaS listener
defined in service object to a BIG-IP virtual server.
"""
def __init__(self, service_adapter, cert_manager, parent_ssl_profile=None):
self.cert_manager = cert_manager
self.parent_ssl_profile = parent_ssl_profile
self.vs_helper = resource_helper.BigIPResourceHelper(
resource_helper.ResourceType.virtual)
self.service_adapter = service_adapter
LOG.debug("ListenerServiceBuilder: using parent_ssl_profile %s ",
parent_ssl_profile)
def create_listener(self, service, bigips, esd=None):
u"""Create listener on set of BIG-IPs.
Create a BIG-IP virtual server to represent an LBaaS
Listener object.
:param service: Dictionary which contains a both a listener
and load balancer definition.
:param bigips: Array of BigIP class instances to create Listener.
"""
loadbalancer = service.get('loadbalancer', dict())
listener = service.get('listener', dict())
network_id = loadbalancer.get('network_id', "")
vip = self.service_adapter.get_virtual(service)
tls = self.service_adapter.get_tls(service)
if tls:
tls['name'] = vip['name']
tls['partition'] = vip['partition']
persist = listener.get("session_persistence", None)
error = None
for bigip in bigips:
self.service_adapter.get_vlan(vip, bigip, network_id)
if tls:
self.add_ssl_profile(tls, vip, bigip)
if persist and persist.get('type', "") == "APP_COOKIE":
self._add_cookie_persist_rule(vip, persist, bigip)
try:
self.vs_helper.create(bigip, vip)
except HTTPError as err:
if err.response.status_code == 409:
LOG.debug("Virtual server already exists...updating")
try:
self.vs_helper.update(bigip, vip)
except Exception as err:
error = f5_ex.VirtualServerUpdateException(
err.message)
LOG.error("Virtual server update error: %s" %
error.message)
else:
error = f5_ex.VirtualServerCreationException(
err.message)
LOG.error("Virtual server creation error: %s" %
error.message)
except Exception as err:
error = f5_ex.VirtualServerCreationException(
err.message)
LOG.error("Virtual server creation error: %s" %
error.message)
if not persist:
try:
self._remove_cookie_persist_rule(vip, bigip)
except HTTPError as err:
LOG.exception(err.message)
return error
def get_listener(self, service, bigip):
u"""Retrieve BIG-IP virtual from a single BIG-IP system.
:param service: Dictionary which contains a both a listener
and load balancer definition.
:param bigip: Array of BigIP class instances to create Listener.
"""
vip = self.service_adapter.get_virtual_name(service)
obj = self.vs_helper.load(bigip=bigip,
name=vip["name"],
partition=vip["partition"])
return obj
def delete_listener(self, service, bigips):
u"""Delete Listener from a set of BIG-IP systems.
Delete virtual server that represents a Listener object.
:param service: Dictionary which contains a both a listener
and load balancer definition.
:param bigips: Array of BigIP class instances to delete Listener.
"""
vip = self.service_adapter.get_virtual_name(service)
tls = self.service_adapter.get_tls(service)
if tls:
tls['name'] = vip['name']
tls['partition'] = vip['partition']
error = None
for bigip in bigips:
try:
self.vs_helper.delete(bigip,
name=vip["name"],
partition=vip["partition"])
except HTTPError as err:
if err.response.status_code != 404:
error = f5_ex.VirtualServerDeleteException(err.message)
LOG.error("Virtual server delete error: %s",
error.message)
except Exception as err:
error = f5_ex.VirtualServerDeleteException(err.message)
LOG.error("Virtual server delete error: %s",
error.message)
# delete ssl profiles
self.remove_ssl_profiles(tls, bigip)
# delete cookie perist rules
try:
self._remove_cookie_persist_rule(vip, bigip)
except HTTPError as err:
LOG.exception(err.message)
return error
def add_ssl_profile(self, tls, vip, bigip):
if "default_tls_container_id" in tls:
container_ref = tls["default_tls_container_id"]
self._create_ssl_profile(
container_ref, bigip, vip, True)
if "sni_containers" in tls and tls["sni_containers"]:
for container in tls["sni_containers"]:
container_ref = container["tls_container_id"]
self._create_ssl_profile(container_ref, bigip, vip, False)
def _create_ssl_profile(
self, container_ref, bigip, vip, sni_default=False):
cert = self.cert_manager.get_certificate(container_ref)
intermediates = self.cert_manager.get_intermediates(container_ref)
key = self.cert_manager.get_private_key(container_ref)
key_passphrase = self.cert_manager.get_private_key_passphrase(
container_ref)
chain = None
if intermediates:
chain = '\n'.join(list(intermediates))
name = self.cert_manager.get_name(container_ref,
self.service_adapter.prefix)
try:
# upload cert/key and create SSL profile
ssl_profile.SSLProfileHelper.create_client_ssl_profile(
bigip, name, cert, key, key_passphrase=key_passphrase,
sni_default=sni_default, intermediates=chain,
parent_profile=self.parent_ssl_profile)
except HTTPError as err:
if err.response.status_code != 409:
LOG.error("SSL profile creation error: %s" %
err.message)
finally:
del key_passphrase
del cert
del chain
del key
# add ssl profile to virtual server
if 'profiles' not in vip:
vip['profiles'] = list()
client_ssl_profile = {'name': name, 'context': "clientside"}
if client_ssl_profile not in vip['profiles']:
vip['profiles'].append(client_ssl_profile)
def remove_ssl_profiles(self, tls, bigip):
if "default_tls_container_id" in tls and \
tls["default_tls_container_id"]:
container_ref = tls["default_tls_container_id"]
try:
i = container_ref.rindex("/") + 1
except ValueError as error:
LOG.exception(error.message)
else:
name = self.service_adapter.prefix + container_ref[i:]
self._remove_ssl_profile(name, bigip)
if "sni_containers" in tls and tls["sni_containers"]:
for container in tls["sni_containers"]:
container_ref = container["tls_container_id"]
try:
i = container_ref.rindex("/") + 1
except ValueError as error:
LOG.exception(error.message)
else:
name = self.service_adapter.prefix + container_ref[i:]
self._remove_ssl_profile(name, bigip)
def _remove_ssl_profile(self, name, bigip):
"""Delete profile.
:param name: Name of profile to delete.
:param bigip: Single BigIP instances to update.
"""
try:
ssl_client_profile = bigip.tm.ltm.profile.client_ssls.client_ssl
if ssl_client_profile.exists(name=name, partition='Common'):
obj = ssl_client_profile.load(name=name, partition='Common')
obj.delete()
except Exception as err:
# Not necessarily an error -- profile might be referenced
# by another virtual server.
LOG.warning(
"Unable to delete profile %s. "
"Response message: %s." % (name, err.message))
def delete_orphaned_listeners(self, service, bigips):
if 'listeners' not in service:
ip_address = service['loadbalancer']['vip_address']
if str(ip_address).endswith('%0'):
ip_address = ip_address[:-2]
for bigip in bigips:
vses = bigip.tm.ltm.virtuals.get_collection()
for vs in vses:
if str(vs.destination).startswith(ip_address):
vs.delete()
else:
listeners = service['listeners']
for listener in listeners:
svc = {"loadbalancer": service["loadbalancer"],
"listener": listener}
vip = self.service_adapter.get_virtual(svc)
for bigip in bigips:
vses = bigip.tm.ltm.virtuals.get_collection()
orphaned = True
for vs in vses:
if vip['destination'] == vs.destination:
if vip['name'] == vs.name:
orphaned = False
else:
orphaned = False
if orphaned:
for vs in vses:
if vip['name'] == vs.name:
vs.delete()
def _add_cookie_persist_rule(self, vip, persistence, bigip):
"""Add cookie persist rules to virtual server instance.
:param vip: Dictionary which contains name and partition of
virtual server.
:param persistence: Persistence definition.
:param bigip: Single BigIP instances to update.
"""
LOG.error("SP_DEBUG: adding cookie persist: %s -- %s",
persistence, vip)
cookie_name = persistence.get('cookie_name', None)
if not cookie_name:
return
rule_name = 'app_cookie_' + vip['name']
rule_def = self._create_app_cookie_persist_rule(cookie_name)
r = bigip.tm.ltm.rules.rule
if not r.exists(name=rule_name, partition=vip["partition"]):
try:
r.create(name=rule_name,
apiAnonymous=rule_def,
partition=vip["partition"])
LOG.debug("Created rule %s" % rule_name)
except Exception as err:
LOG.error("Failed to create rule %s", rule_name)
u = bigip.tm.ltm.persistence.universals.universal
if not u.exists(name=rule_name, partition=vip["partition"]):
try:
u.create(name=rule_name,
rule=rule_name,
partition=vip["partition"])
LOG.debug("Created persistence universal %s" % rule_name)
except Exception as err:
LOG.error("Failed to create persistence universal %s" %
rule_name)
LOG.exception(err)
def _create_app_cookie_persist_rule(self, cookiename):
"""Create cookie persistence rule.
:param cookiename: Name to substitute in rule.
"""
rule_text = "when HTTP_REQUEST {\n"
rule_text += " if { [HTTP::cookie " + str(cookiename)
rule_text += "] ne \"\" }{\n"
rule_text += " persist uie [string tolower [HTTP::cookie \""
rule_text += cookiename + "\"]] 3600\n"
rule_text += " }\n"
rule_text += "}\n\n"
rule_text += "when HTTP_RESPONSE {\n"
rule_text += " if { [HTTP::cookie \"" + str(cookiename)
rule_text += "\"] ne \"\" }{\n"
rule_text += " persist add uie [string tolower [HTTP::cookie \""
rule_text += cookiename + "\"]] 3600\n"
rule_text += " }\n"
rule_text += "}\n\n"
return rule_text
def _remove_cookie_persist_rule(self, vip, bigip):
"""Delete cookie persist rule.
:param vip: Dictionary which contains name and partition of
virtual server.
:param bigip: Single BigIP instances to update.
"""
rule_name = 'app_cookie_' + vip['name']
u = bigip.tm.ltm.persistence.universals.universal
if u.exists(name=rule_name, partition=vip["partition"]):
obj = u.load(name=rule_name, partition=vip["partition"])
obj.delete()
LOG.debug("Deleted persistence universal %s" % rule_name)
r = bigip.tm.ltm.rules.rule
if r.exists(name=rule_name, partition=vip["partition"]):
obj = r.load(name=rule_name, partition=vip["partition"])
obj.delete()
LOG.debug("Deleted rule %s" % rule_name)
def get_stats(self, service, bigips, stat_keys):
"""Return stat values for a single virtual.
Stats to collect are defined as an array of strings in input stats.
Values are summed across one or more BIG-IPs defined in input bigips.
:param service: Has listener name/partition
:param bigips: One or more BIG-IPs to get listener stats from.
:param stat_keys: Array of strings that define which stats to collect.
:return: A dict with key/value pairs for each stat defined in
input stats.
"""
collected_stats = {}
for stat_key in stat_keys:
collected_stats[stat_key] = 0
virtual = self.service_adapter.get_virtual(service)
part = virtual["partition"]
for bigip in bigips:
try:
vs_stats = self.vs_helper.get_stats(
bigip,
name=virtual["name"],
partition=part,
stat_keys=stat_keys)
for stat_key in stat_keys:
if stat_key in vs_stats:
collected_stats[stat_key] += vs_stats[stat_key]
except Exception as e:
# log error but continue on
LOG.error("Error getting virtual server stats: %s", e.message)
return collected_stats
| {
"content_hash": "50cdef07fc3e78df91dfa54e9f549869",
"timestamp": "",
"source": "github",
"line_count": 386,
"max_line_length": 79,
"avg_line_length": 40.012953367875646,
"alnum_prop": 0.5467788928455811,
"repo_name": "F5Networks/f5-openstack-agent",
"id": "ebb49a64e5b83af05fbe67d25b3b1c78e432409e",
"size": "16053",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "f5_openstack_agent/lbaasv2/drivers/bigip/listener_service.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "Dockerfile",
"bytes": "2220"
},
{
"name": "Makefile",
"bytes": "853"
},
{
"name": "Python",
"bytes": "1395055"
},
{
"name": "Ruby",
"bytes": "78"
},
{
"name": "Shell",
"bytes": "15836"
}
],
"symlink_target": ""
} |
from django.db import models
from django.contrib.auth.models import User
class BlogPost(models.Model):
post_date = models.DateTimeField(auto_now_add=True)
update_date = models.DateTimeField(auto_now=True)
edited = models.BooleanField()
draft = models.BooleanField()
author = models.ForeignKey(User)
title = models.CharField(max_length=80)
content = models.TextField()
| {
"content_hash": "245ec5c34752a795835ba41355d83921",
"timestamp": "",
"source": "github",
"line_count": 11,
"max_line_length": 55,
"avg_line_length": 36.09090909090909,
"alnum_prop": 0.7355163727959698,
"repo_name": "d3matt/d3matt.com",
"id": "78c1b4ce0ce334876860ae6dcf0fdd7c272d2910",
"size": "397",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "src/d3matt/blog/models.py",
"mode": "33188",
"license": "bsd-2-clause",
"language": [
{
"name": "Python",
"bytes": "5722"
},
{
"name": "Shell",
"bytes": "1267"
}
],
"symlink_target": ""
} |
from .users import *
from .departments import *
from .auth import * | {
"content_hash": "5dcc04231b0b64e3d0687ae9cf8cf3a0",
"timestamp": "",
"source": "github",
"line_count": 3,
"max_line_length": 26,
"avg_line_length": 22.333333333333332,
"alnum_prop": 0.746268656716418,
"repo_name": "MishaGarbuz/WinVault",
"id": "542b26ac771a46f2c3bf9c32ed45dfd24dafecfd",
"size": "67",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "Application/controllers/__init__.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "1499300"
},
{
"name": "HTML",
"bytes": "846"
},
{
"name": "JavaScript",
"bytes": "1500793"
},
{
"name": "Python",
"bytes": "2377"
}
],
"symlink_target": ""
} |
class SanicMeta(type):
@classmethod
def __prepare__(metaclass, name, bases, **kwds):
cls = super().__prepare__(metaclass, name, bases, **kwds)
cls["__slots__"] = ()
return cls
| {
"content_hash": "ec6209f530dcbe77daaed8f58055544d",
"timestamp": "",
"source": "github",
"line_count": 6,
"max_line_length": 65,
"avg_line_length": 34.666666666666664,
"alnum_prop": 0.5528846153846154,
"repo_name": "ashleysommer/sanic",
"id": "2c6870c2598422fb8e2588d725a10a2e4bce0744",
"size": "208",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "sanic/base/meta.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Dockerfile",
"bytes": "159"
},
{
"name": "Go",
"bytes": "482"
},
{
"name": "HTML",
"bytes": "1173"
},
{
"name": "Makefile",
"bytes": "2412"
},
{
"name": "Python",
"bytes": "962491"
}
],
"symlink_target": ""
} |
from django.db import models
from django.db.models import Q
from django.contrib.auth.models import User
from django.core.paginator import ObjectPaginator, InvalidPage
import re
import urlparse
from datetime import datetime, timedelta
from gabaluu.form_choices import COMMENT_TYPES
class Site(object):
pass
class Tag(models.Model):
name = models.CharField(maxlength=100)
count = models.IntegerField()
def _get_font_size(self):
count = self.count + 10
return "font-size: %spx;" % count
font_size = property(_get_font_size)
@classmethod
def find_all(cls, site):
return Tag.objects.all()
@classmethod
def find_or_create(cls, name, new_synopsis=True):
tag, created = Tag.objects.get_or_create(name=name, defaults={'count': 0 })
if new_synopsis or (not new_synopsis and created):
tag.count = tag.count + 1
return tag
@classmethod
def find_by(cls, name):
tags = Tag.objects.filter(name=str(name).strip())
if tags.count() == 0:
return None
return tags[0]
@classmethod
def parse(cls, tags):
"""
Parses a comma separated list of tags into
tag names handles all kinds of different tags.
(comma seperated, space seperated)
Todo...Enhance to support more formats (in quotes)
"""
return re.split('[,\\s]+', tags)
class Synopsis(models.Model):
"""
A synopsis of a web resource.
"""
title = models.CharField(maxlength=50)
permalink = models.CharField(maxlength=100)
text = models.CharField(maxlength=5000)
article_site_url = models.CharField(maxlength=500)
article_url = models.CharField(maxlength=500)
pub_date = models.DateTimeField(editable=False)
updated_date = models.DateTimeField(editable=False, blank=True, null=True)
author = models.ForeignKey(User, related_name='author_id')
tags = models.ManyToManyField(Tag)
score = models.IntegerField()
def __str__( self ):
return self.title
def get_absolute_url(self):
return "http://zenopsis.com/synopsis/%s/" % self.permalink
def is_author_of_synopsis(self, user):
if self.author.username == user.username:
return True
return False
@classmethod
def create_permalink(cls, title, article_url):
url_parts = urlparse.urlparse(article_url)
title = Synopsis._remove_special_char(title)
return "_".join((url_parts[1].replace('.', '_'), title))
@classmethod
def _remove_special_char(cls, string):
string = string.strip().replace(' ', '_')
string = string.replace("'", "")
string = string.replace("$", "")
string = string.replace("&", "")
string = string.replace("<", "")
string = string.replace(">", "")
string = string.replace("*", "")
string = string.replace("@", "")
string = string.replace(".", "")
string = string.replace(":", "")
string = string.replace("|", "")
string = string.replace("~", "")
string = string.replace("`", "")
string = string.replace("(", "")
string = string.replace(")", "")
string = string.replace("%", "")
string = string.replace("#", "")
string = string.replace("^", "")
string = string.replace("?", "")
string = string.replace("/", "")
string = string.replace("{", "")
string = string.replace("}", "")
string = string.replace(",", "")
string = string.replace(";", "")
string = string.replace("!", "")
string = string.replace("+", "")
string = string.replace("=", "")
string = string.replace("-", "_")
return string
@classmethod
def _run_query(cls, query, pagination=False, current_page=0, items_per_page=10):
if pagination:
paginator = ObjectPaginator(query, items_per_page)
synopsis_list = paginator.get_page(current_page)
else:
paginator = None
synopsis_list = query
return synopsis_list, paginator
@classmethod
def most_recent(cls, pagination=False, current_page=0, items_per_page=10):
return Synopsis._run_query(Synopsis.objects.all().order_by('-pub_date'),
pagination=pagination,
current_page=current_page,
items_per_page=items_per_page)
@classmethod
def popular(cls, pagination=False, current_page=0, items_per_page=10):
return Synopsis._run_query(Synopsis.objects.all().order_by('-score', '-pub_date'),
pagination=pagination,
current_page=current_page,
items_per_page=items_per_page)
@classmethod
def by_tag(cls, tag, pagination=False, current_page=0, items_per_page=10):
return Synopsis._run_query(Synopsis.objects.filter(tags__name__exact=tag).order_by('-pub_date'),
pagination=pagination,
current_page=current_page,
items_per_page=items_per_page)
@classmethod
def user_posted_synopsis_list(cls, user):
return Synopsis.objects.filter(author=user).order_by('-pub_date')
@classmethod
def user_voted_synopsis_list(cls, user):
election_list = Election.objects.filter(user=user).order_by('-date')
return [election.synopsis for election in election_list]
@classmethod
def user_commented_synopsis_list(cls, user):
comment_list = Comment.objects.filter(posted_by=user).order_by('-date')
return [comment.synopsis for comment in comment_list]
@classmethod
def query(cls, query):
# todo -- improve search logic to search across all model fields
return Synopsis.objects.filter(title__icontains=query)
@classmethod
def by_article_site(cls, site):
article_site_url = "http://%s" % site.replace('_', '.')
return Synopsis.objects.filter(article_site_url=article_site_url).order_by('-pub_date')
def _published(self):
"""Return the synopsis formated published date."""
return self.pub_date.strftime('%B %d, %Y')
published = property(_published)
def _tags_as_string(self):
tags_string = ""
for tag in self.tags.all():
tags_string = ' '.join((tags_string, tag.name))
return tags_string.strip()
tags_as_string = property(_tags_as_string)
def _short_text(self):
text = "%s <a href='/synopsis/%s'>More >> </a>" % (self.text[:200],
self.permalink)
return text
short_text = property(_short_text)
def _short_text_preview(self):
text = "<h2>%s</h2> %s <a href='/synopsis/%s' target='_top'>More >> </a>" % (self.title,
self.text[:200],
self.permalink)
return text
short_text_preview = property(_short_text_preview)
def _get_comments(self):
"""Return list of comments on this synopsis. """
return Comment.objects.filter(synopsis=self, type_of="1", reply_to__isnull=True)
comments = property(_get_comments)
def _number_of_comments(self):
count = len(Comment.objects.filter(synopsis=self, type_of="1"))
if count == 1:
return str(count) + " comment"
else:
return str(count) + " comments"
number_of_comments = property(_number_of_comments)
def _get_revisions(self):
"""Return list of revision comments on this synopsis. """
return Comment.objects.filter(synopsis=self, type_of="2")
revisions = property(_get_revisions)
def _get_votes(self):
count = self.score
if count == 1:
return str(count) + " vote"
else:
return str(count) + " votes"
votes = property(_get_votes)
@classmethod
def article_site_list(cls):
from django.db import connection
cursor = connection.cursor()
sql = """select article_site_url, count(article_site_url) from synopsis_synopsis
group by article_site_url having count(article_site_url) >= 1 """
cursor.execute(sql)
rows = cursor.fetchall()
site_list = []
for row in rows:
url_parts = urlparse.urlparse(row[0])
site = Site()
site.key = url_parts[1].replace('.', '_')
site.url = url_parts[1]
site.count = row[1]
site_list.append(site)
return site_list
@classmethod
def tag_and_article_site_list(cls):
site_list = Synopsis.article_site_list()
tag_list = Tag.objects.all()
tags = []
for t in tag_list:
t.uri = "/tags/%s/" % t.name
tags.append(t)
for site in site_list:
tag = Tag()
tag.uri = "/sites/%s/" % site.key
tag.name = site.key.replace('_', '.')
tag.name = tag.name.replace('www.', '')
tag.count = site.count
tags.append(tag)
return tags
class Election(models.Model):
"""
Map if a user voted on a synopsis.
"""
synopsis = models.ForeignKey(Synopsis)
user = models.ForeignKey(User)
date = models.DateTimeField(editable=False)
@classmethod
def has_voted(cls, user, synopsis):
try:
election = Election.objects.get(user__id=user.id,
synopsis__id=synopsis.id)
except:
return False
return True
@classmethod
def vote(cls, synopsis, user):
election = Election.objects.create(user=user,
synopsis=synopsis,
date=datetime.now())
synopsis.score = synopsis.score + 1
synopsis.save()
return synopsis.votes
class Comment(models.Model):
posted_by = models.ForeignKey(User, related_name='posted_by_id')
text = models.CharField(maxlength=5000)
date = models.DateTimeField(editable=False)
type_of = models.CharField(maxlength=50)
synopsis = models.ForeignKey(Synopsis)
reply_to = models.IntegerField(blank=True, null=True)
def _get_formated_dated(self):
"""Return formated date. """
return self.date.strftime('%m/%d/%Y')
formated_date = property(_get_formated_dated)
def _get_comments(self):
"""Return list of comments on this comment. """
return Comment.objects.filter(reply_to=self.id)
comments = property(_get_comments)
def _get_comment_type(self):
"""Return comment type. """
comment_type = "None"
for t in COMMENT_TYPES:
if t[0] == int(self.type_of):
comment_type = t[1]
return comment_type
comment_type = property(_get_comment_type)
def _short_text(self):
text = "%s..<br/><a href='/synopsis/%s#comments-section'>More >></a>" % (self.text[:80],
self.synopsis.permalink)
return text
short_text = property(_short_text)
def is_revision(self):
if self.type_of == "2":
return True
@classmethod
def most_recent(cls):
return Comment.objects.all().order_by('-date')[:8]
@classmethod
def type_from_friendly_name(cls, name):
for t in COMMENT_TYPES:
if t[1].lower() == name.lower():
return t[0]
return "1"
| {
"content_hash": "2d7cc7585ebf110a954d4ad513d5c74f",
"timestamp": "",
"source": "github",
"line_count": 354,
"max_line_length": 106,
"avg_line_length": 35.090395480225986,
"alnum_prop": 0.5378360972468201,
"repo_name": "CarlosGabaldon/zenopsis",
"id": "35656abf2b1b7e5d755289bbd91a38189a027842",
"size": "12422",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "synopsis/models.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "JavaScript",
"bytes": "85945"
},
{
"name": "Python",
"bytes": "68596"
}
],
"symlink_target": ""
} |
from setuptools import setup
with open("README.rst") as f:
long_description = f.read()
version = "0.0.1"
setup(
name="lunar",
version=version,
packages=["lunar"],
author="jasonlyu",
author_email="[email protected]",
description="lunar is a WSGI based webframework in pure Python, without any third-party dependency.",
classifiers=[
"Environment :: Web Environment",
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Internet :: WWW/HTTP :: Dynamic Content",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description=long_description,
)
| {
"content_hash": "3d57ade3c2508ccf093954571ac8c24f",
"timestamp": "",
"source": "github",
"line_count": 24,
"max_line_length": 105,
"avg_line_length": 30.125,
"alnum_prop": 0.6445366528354081,
"repo_name": "jasonlvhit/lunar",
"id": "15b0ffca935f94cc34d96048d77affbafab8d84c",
"size": "723",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "setup.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "CSS",
"bytes": "110"
},
{
"name": "HTML",
"bytes": "1243"
},
{
"name": "Python",
"bytes": "108332"
},
{
"name": "Shell",
"bytes": "98"
}
],
"symlink_target": ""
} |
import numpy as np
import pandas as pd
from scipy.stats.distributions import chi2, norm
from statsmodels.graphics import utils
def _calc_survfunc_right(time, status, weights=None, compress=True,
retall=True):
"""
Calculate the survival function and its standard error for a single
group.
"""
# Convert the unique times to ranks (0, 1, 2, ...)
utime, rtime = np.unique(time, return_inverse=True)
# Number of deaths at each unique time.
if weights is None:
d = np.bincount(rtime, weights=status)
else:
d = np.bincount(rtime, weights=status*weights)
# Size of risk set just prior to each event time.
if weights is None:
n = np.bincount(rtime)
else:
n = np.bincount(rtime, weights=weights)
n = np.cumsum(n[::-1])[::-1]
# Only retain times where an event occured.
if compress:
ii = np.flatnonzero(d > 0)
d = d[ii]
n = n[ii]
utime = utime[ii]
# The survival function probabilities.
sp = 1 - d / n.astype(np.float64)
sp = np.log(sp)
sp = np.cumsum(sp)
sp = np.exp(sp)
if not retall:
return sp, utime, rtime, n, d
# Standard errors
if weights is None:
# Greenwood's formula
se = d / (n * (n - d)).astype(np.float64)
se = np.cumsum(se)
se = np.sqrt(se)
se *= sp
else:
# Tsiatis' (1981) formula
se = d / (n * n).astype(np.float64)
se = np.cumsum(se)
se = np.sqrt(se)
return sp, se, utime, rtime, n, d
def _calc_incidence_right(time, status, weights=None):
"""
Calculate the cumulative incidence function and its standard error.
"""
# Calculate the all-cause survival function.
status0 = (status >= 1).astype(np.float64)
sp, utime, rtime, n, d = _calc_survfunc_right(time, status0, weights,
compress=False, retall=False)
ngrp = status.max()
# Number of cause-specific deaths at each unique time.
d = []
for k in range(ngrp):
status0 = (status == k + 1).astype(np.float64)
if weights is None:
d0 = np.bincount(rtime, weights=status0, minlength=len(utime))
else:
d0 = np.bincount(rtime, weights=status0*weights,
minlength=len(utime))
d.append(d0)
# The cumulative incidence function probabilities.
ip = []
sp0 = np.r_[1, sp[:-1]] / n
for k in range(ngrp):
ip0 = np.cumsum(sp0 * d[k])
ip.append(ip0)
# The standard error of the cumulative incidence function.
if weights is not None:
return ip, None, utime
se = []
da = sum(d)
for k in range(ngrp):
ra = da / (n * (n - da))
v = ip[k]**2 * np.cumsum(ra)
v -= 2 * ip[k] * np.cumsum(ip[k] * ra)
v += np.cumsum(ip[k]**2 * ra)
ra = (n - d[k]) * d[k] / n
v += np.cumsum(sp0**2 * ra)
ra = sp0 * d[k] / n
v -= 2 * ip[k] * np.cumsum(ra)
v += 2 * np.cumsum(ip[k] * ra)
se.append(np.sqrt(v))
return ip, se, utime
def _checkargs(time, status, freq_weights):
if len(time) != len(status):
raise ValueError("time and status must have the same length")
if freq_weights is not None and (len(freq_weights) != len(time)):
raise ValueError("weights, time and status must have the same length")
class CumIncidenceRight(object):
"""
Estimation and inference for a cumulative incidence function.
If J = 1, 2, ... indicates the event type, the cumulative
incidence function for cause j is:
I(t, j) = P(T <= t and J=j)
Only right censoring is supported. If frequency weights are provided,
the point estimate is returned without a standard error.
Parameters
----------
time : array-like
An array of times (censoring times or event times)
status : array-like
If status >= 1 indicates which event occured at time t. If
status = 0, the subject was censored at time t.
title : string
Optional title used for plots and summary output.
freq_weights : array-like
Optional frequency weights
Attributes
----------
times : array-like
The distinct times at which the incidence rates are estimated
cinc : list of arrays
cinc[k-1] contains the estimated cumulative incidence rates
for outcome k=1,2,...
cinc_se : list of arrays
The standard errors for the values in `cinc`.
References
----------
The Stata stcompet procedure:
http://www.stata-journal.com/sjpdf.html?articlenum=st0059
Dinse, G. E. and M. G. Larson. 1986. A note on semi-Markov models
for partially censored data. Biometrika 73: 379-386.
Marubini, E. and M. G. Valsecchi. 1995. Analysing Survival Data
from Clinical Trials and Observational Studies. Chichester, UK:
John Wiley & Sons.
"""
def __init__(self, time, status, title=None, freq_weights=None):
_checkargs(time, status, freq_weights)
time = self.time = np.asarray(time)
status = self.status = np.asarray(status)
if freq_weights is not None:
freq_weights = self.freq_weights = np.asarray(freq_weights)
x = _calc_incidence_right(time, status, freq_weights)
self.cinc = x[0]
self.cinc_se = x[1]
self.times = x[2]
self.title = "" if not title else title
class SurvfuncRight(object):
"""
Estimation and inference for a survival function.
The survival function S(t) = P(T > t) is the probability that an
event time T is greater than t.
This class currently only supports right censoring.
Parameters
----------
time : array-like
An array of times (censoring times or event times)
status : array-like
Status at the event time, status==1 is the 'event'
(e.g. death, failure), meaning that the event
occurs at the given value in `time`; status==0
indicates that censoring has occured, meaning that
the event occurs after the given value in `time`.
title : string
Optional title used for plots and summary output.
freq_weights : array-like
Optional frequency weights
Attributes
----------
surv_prob : array-like
The estimated value of the survivor function at each time
point in `surv_times`.
surv_prob_se : array-like
The standard errors for the values in `surv_prob`.
surv_times : array-like
The points where the survival function changes.
n_risk : array-like
The number of subjects at risk just before each time value in
`surv_times`.
n_events : array-like
The number of events (e.g. deaths) that occur at each point
in `surv_times`.
"""
def __init__(self, time, status, title=None, freq_weights=None):
_checkargs(time, status, freq_weights)
time = self.time = np.asarray(time)
status = self.status = np.asarray(status)
if freq_weights is not None:
freq_weights = self.freq_weights = np.asarray(freq_weights)
x = _calc_survfunc_right(time, status, freq_weights)
self.surv_prob = x[0]
self.surv_prob_se = x[1]
self.surv_times = x[2]
self.n_risk = x[4]
self.n_events = x[5]
self.title = "" if not title else title
def plot(self, ax=None):
"""
Plot the survival function.
Examples
--------
Change the line color:
>>> import statsmodels.api as sm
>>> data = sm.datasets.get_rdataset("flchain", "survival").data
>>> df = data.loc[data.sex == "F", :]
>>> sf = sm.SurvfuncRight(df["futime"], df["death"])
>>> fig = sf.plot()
>>> ax = fig.get_axes()[0]
>>> li = ax.get_lines()
>>> li[0].set_color('purple')
>>> li[1].set_color('purple')
Don't show the censoring points:
>>> fig = sf.plot()
>>> ax = fig.get_axes()[0]
>>> li = ax.get_lines()
>>> li[1].set_visible(False)
"""
return plot_survfunc(self, ax)
def quantile(self, p):
"""
Estimated quantile of a survival distribution.
Parameters
----------
p : float
The probability point at which the quantile
is determined.
Returns the estimated quantile.
"""
# SAS uses a strict inequality here.
ii = np.flatnonzero(self.surv_prob < 1 - p)
if len(ii) == 0:
return np.nan
return self.surv_times[ii[0]]
def quantile_ci(self, p, alpha=0.05, method='cloglog'):
"""
Returns a confidence interval for a survival quantile.
Parameters
----------
p : float
The probability point for which a confidence interval is
determined.
alpha : float
The confidence interval has nominal coverage probability
1 - `alpha`.
method : string
Function to use for g-transformation, must be ...
Returns
-------
lb : float
The lower confidence limit.
ub : float
The upper confidence limit.
Notes
-----
The confidence interval is obtained by inverting Z-tests. The
limits of the confidence interval will always be observed
event times.
References
----------
The method is based on the approach used in SAS, documented here:
http://support.sas.com/documentation/cdl/en/statug/68162/HTML/default/viewer.htm#statug_lifetest_details03.htm
"""
tr = norm.ppf(1 - alpha / 2)
method = method.lower()
if method == "cloglog":
g = lambda x: np.log(-np.log(x))
gprime = lambda x: -1 / (x * np.log(x))
elif method == "linear":
g = lambda x: x
gprime = lambda x: 1
elif method == "log":
g = lambda x: np.log(x)
gprime = lambda x: 1 / x
elif method == "logit":
g = lambda x: np.log(x / (1 - x))
gprime = lambda x: 1 / (x * (1 - x))
elif method == "asinsqrt":
g = lambda x: np.arcsin(np.sqrt(x))
gprime = lambda x: 1 / (2 * np.sqrt(x) * np.sqrt(1 - x))
else:
raise ValueError("unknown method")
r = g(self.surv_prob) - g(1 - p)
r /= (gprime(self.surv_prob) * self.surv_prob_se)
ii = np.flatnonzero(np.abs(r) <= tr)
if len(ii) == 0:
return np.nan, np.nan
lb = self.surv_times[ii[0]]
if ii[-1] == len(self.surv_times) - 1:
ub = np.inf
else:
ub = self.surv_times[ii[-1] + 1]
return lb, ub
def summary(self):
"""
Return a summary of the estimated survival function.
The summary is a datafram containing the unique event times,
estimated survival function values, and related quantities.
"""
df = pd.DataFrame(index=self.surv_times)
df.index.name = "Time"
df["Surv prob"] = self.surv_prob
df["Surv prob SE"] = self.surv_prob_se
df["num at risk"] = self.n_risk
df["num events"] = self.n_events
return df
def simultaneous_cb(self, alpha=0.05, method="hw", transform="log"):
"""
Returns a simultaneous confidence band for the survival function.
Parameters
----------
alpha : float
`1 - alpha` is the desired simultaneous coverage
probability for the confidence region. Currently alpha
must be set to 0.05, giving 95% simultaneous intervals.
method : string
The method used to produce the simultaneous confidence
band. Only the Hall-Wellner (hw) method is currently
implemented.
transform : string
The used to produce the interval (note that the returned
interval is on the survival probability scale regardless
of which transform is used). Only `log` and `arcsin` are
implemented.
Returns
-------
lcb : array-like
The lower confidence limits corresponding to the points
in `surv_times`.
ucb : array-like
The upper confidence limits corresponding to the points
in `surv_times`.
"""
method = method.lower()
if method != "hw":
msg = "only the Hall-Wellner (hw) method is implemented"
raise ValueError(msg)
if alpha != 0.05:
raise ValueError("alpha must be set to 0.05")
transform = transform.lower()
s2 = self.surv_prob_se**2 / self.surv_prob**2
nn = self.n_risk
if transform == "log":
denom = np.sqrt(nn) * np.log(self.surv_prob)
theta = 1.3581 * (1 + nn * s2) / denom
theta = np.exp(theta)
lcb = self.surv_prob**(1/theta)
ucb = self.surv_prob**theta
elif transform == "arcsin":
k = 1.3581
k *= (1 + nn * s2) / (2 * np.sqrt(nn))
k *= np.sqrt(self.surv_prob / (1 - self.surv_prob))
f = np.arcsin(np.sqrt(self.surv_prob))
v = np.clip(f - k, 0, np.inf)
lcb = np.sin(v)**2
v = np.clip(f + k, -np.inf, np.pi/2)
ucb = np.sin(v)**2
else:
raise ValueError("Unknown transform")
return lcb, ucb
def survdiff(time, status, group, weight_type=None, strata=None, **kwargs):
"""
Test for the equality of two survival distributions.
Parameters:
-----------
time : array-like
The event or censoring times.
status : array-like
The censoring status variable, status=1 indicates that the
event occured, status=0 indicates that the observation was
censored.
group : array-like
Indicators of the two groups
weight_type : string
The following weight types are implemented:
None (default) : logrank test
fh : Fleming-Harrington, weights by S^(fh_p),
requires exponent fh_p to be provided as keyword
argument; the weights are derived from S defined at
the previous event time, and the first weight is
always 1.
gb : Gehan-Breslow, weights by the number at risk
tw : Tarone-Ware, weights by the square root of the number
at risk
strata : array-like
Optional stratum indicators for a stratified test
Returns
--------
chisq : The chi-square (1 degree of freedom) distributed test
statistic value
pvalue : The p-value for the chi^2 test
"""
# TODO: extend to handle more than two groups
time = np.asarray(time)
status = np.asarray(status)
group = np.asarray(group)
gr = np.unique(group)
if len(gr) != 2:
raise ValueError("logrank only supports two groups")
if strata is None:
obs, var = _survdiff(time, status, group, weight_type, gr,
**kwargs)
else:
strata = np.asarray(strata)
stu = np.unique(strata)
obs, var = 0., 0.
for st in stu:
# could be more efficient?
ii = (strata == st)
obs1, var1 = _survdiff(time[ii], status[ii], group[ii],
weight_type, gr, **kwargs)
obs += obs1
var += var1
zstat = obs / np.sqrt(var)
# The chi^2 test statistic and p-value.
chisq = zstat**2
pvalue = 1 - chi2.cdf(chisq, 1)
return chisq, pvalue
def _survdiff(time, status, group, weight_type, gr, **kwargs):
# logrank test for one stratum
ii = (group == gr[0])
time1 = time[ii]
status1 = status[ii]
ii = (group == gr[1])
time2 = time[ii]
status2 = status[ii]
# Get the unique times.
utimes = np.unique(time)
status1 = status1.astype(np.bool)
status2 = status2.astype(np.bool)
# The positions of the observed event times in each group, in the
# overall list of unique times.
ix1 = np.searchsorted(utimes, time1[status1])
ix2 = np.searchsorted(utimes, time2[status2])
# Number of events observed at each time point, per group and
# overall.
obs1 = np.bincount(ix1, minlength=len(utimes))
obs2 = np.bincount(ix2, minlength=len(utimes))
obs = obs1 + obs2
# Risk set size at each time point, per group and overall.
nvec = []
for time0 in time1, time2:
ix = np.searchsorted(utimes, time0)
n = np.bincount(ix, minlength=len(utimes))
n = np.cumsum(n)
n = np.roll(n, 1)
n[0] = 0
n = len(time0) - n
nvec.append(n)
n1, n2 = tuple(nvec)
n = n1 + n2
# The variance of event counts in the first group.
r = n1 / n.astype(np.float64)
var = obs * r * (1 - r) * (n - obs) / (n - 1)
# The expected number of events in the first group.
exp1 = obs * r
weights = None
if weight_type is not None:
weight_type = weight_type.lower()
if weight_type == "gb":
weights = n
elif weight_type == "tw":
weights = np.sqrt(n)
elif weight_type == "fh":
if "fh_p" not in kwargs:
msg = "weight_type type 'fh' requires specification of fh_p"
raise ValueError(msg)
fh_p = kwargs["fh_p"]
# Calculate the survivor function directly to avoid the
# overhead of creating a SurvfuncRight object
sp = 1 - obs / n.astype(np.float64)
sp = np.log(sp)
sp = np.cumsum(sp)
sp = np.exp(sp)
weights = sp**fh_p
weights = np.roll(weights, 1)
weights[0] = 1
else:
raise ValueError("weight_type not implemented")
# The Z-scale test statistic (compare to normal reference
# distribution).
ix = np.flatnonzero(n > 1)
if weights is None:
obs = np.sum(obs1[ix] - exp1[ix])
var = np.sum(var[ix])
else:
obs = np.dot(weights[ix], obs1[ix] - exp1[ix])
var = np.dot(weights[ix]**2, var[ix])
return obs, var
def plot_survfunc(survfuncs, ax=None):
"""
Plot one or more survivor functions.
Parameters
----------
survfuncs : object or array-like
A single SurvfuncRight object, or a list or SurvfuncRight
objects that are plotted together.
Returns
-------
A figure instance on which the plot was drawn.
Examples
--------
Add a legend:
>>> import statsmodels.api as sm
>>> from statsmodels.duration.survfunc import plot_survfunc
>>> data = sm.datasets.get_rdataset("flchain", "survival").data
>>> df = data.loc[data.sex == "F", :]
>>> sf0 = sm.SurvfuncRight(df["futime"], df["death"])
>>> sf1 = sm.SurvfuncRight(3.0 * df["futime"], df["death"])
>>> fig = plot_survfunc([sf0, sf1])
>>> ax = fig.get_axes()[0]
>>> ax.set_position([0.1, 0.1, 0.64, 0.8])
>>> ha, lb = ax.get_legend_handles_labels()
>>> leg = fig.legend((ha[0], ha[1]), (lb[0], lb[1]), 'center right')
Change the line colors:
>>> fig = plot_survfunc([sf0, sf1])
>>> ax = fig.get_axes()[0]
>>> ax.set_position([0.1, 0.1, 0.64, 0.8])
>>> ha, lb = ax.get_legend_handles_labels()
>>> ha[0].set_color('purple')
>>> ha[1].set_color('orange')
"""
fig, ax = utils.create_mpl_ax(ax)
# If we have only a single survival function to plot, put it into
# a list.
try:
assert(type(survfuncs[0]) is SurvfuncRight)
except:
survfuncs = [survfuncs]
for gx, sf in enumerate(survfuncs):
# The estimated survival function does not include a point at
# time 0, include it here for plotting.
surv_times = np.concatenate(([0], sf.surv_times))
surv_prob = np.concatenate(([1], sf.surv_prob))
# If the final times are censoring times they are not included
# in the survival function so we add them here
mxt = max(sf.time)
if mxt > surv_times[-1]:
surv_times = np.concatenate((surv_times, [mxt]))
surv_prob = np.concatenate((surv_prob, [surv_prob[-1]]))
label = getattr(sf, "title", "Group %d" % (gx + 1))
li, = ax.step(surv_times, surv_prob, '-', label=label, lw=2,
where='post')
# Plot the censored points.
ii = np.flatnonzero(np.logical_not(sf.status))
ti = sf.time[ii]
jj = np.searchsorted(surv_times, ti) - 1
sp = surv_prob[jj]
ax.plot(ti, sp, '+', ms=12, color=li.get_color(),
label=label + " points")
ax.set_ylim(0, 1.01)
return fig
| {
"content_hash": "b4ba3a5303fa153f58914aa649c6d7f9",
"timestamp": "",
"source": "github",
"line_count": 673,
"max_line_length": 120,
"avg_line_length": 31.227340267459137,
"alnum_prop": 0.5614293871336125,
"repo_name": "yl565/statsmodels",
"id": "abe0a84425292fedd864afd3040deb771a8391f6",
"size": "21016",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "statsmodels/duration/survfunc.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "AGS Script",
"bytes": "457842"
},
{
"name": "Assembly",
"bytes": "10035"
},
{
"name": "Batchfile",
"bytes": "351"
},
{
"name": "C",
"bytes": "12088"
},
{
"name": "HTML",
"bytes": "148470"
},
{
"name": "Matlab",
"bytes": "2609"
},
{
"name": "Python",
"bytes": "9670281"
},
{
"name": "R",
"bytes": "55204"
},
{
"name": "Stata",
"bytes": "54989"
}
],
"symlink_target": ""
} |
from __future__ import absolute_import, division, print_function
from cryptography import utils
from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
from cryptography.hazmat.primitives import hashes
@utils.register_interface(hashes.HashContext)
class _HashContext(object):
def __init__(self, backend, algorithm, ctx=None):
self._algorithm = algorithm
self._backend = backend
if ctx is None:
ctx = self._backend._lib.Cryptography_EVP_MD_CTX_new()
ctx = self._backend._ffi.gc(
ctx, self._backend._lib.Cryptography_EVP_MD_CTX_free
)
evp_md = self._backend._lib.EVP_get_digestbyname(
algorithm.name.encode("ascii"))
if evp_md == self._backend._ffi.NULL:
raise UnsupportedAlgorithm(
"{0} is not a supported hash on this backend.".format(
algorithm.name),
_Reasons.UNSUPPORTED_HASH
)
res = self._backend._lib.EVP_DigestInit_ex(ctx, evp_md,
self._backend._ffi.NULL)
self._backend.openssl_assert(res != 0)
self._ctx = ctx
algorithm = utils.read_only_property("_algorithm")
def copy(self):
copied_ctx = self._backend._lib.Cryptography_EVP_MD_CTX_new()
copied_ctx = self._backend._ffi.gc(
copied_ctx, self._backend._lib.Cryptography_EVP_MD_CTX_free
)
res = self._backend._lib.EVP_MD_CTX_copy_ex(copied_ctx, self._ctx)
self._backend.openssl_assert(res != 0)
return _HashContext(self._backend, self.algorithm, ctx=copied_ctx)
def update(self, data):
res = self._backend._lib.EVP_DigestUpdate(self._ctx, data, len(data))
self._backend.openssl_assert(res != 0)
def finalize(self):
buf = self._backend._ffi.new("unsigned char[]",
self._backend._lib.EVP_MAX_MD_SIZE)
outlen = self._backend._ffi.new("unsigned int *")
res = self._backend._lib.EVP_DigestFinal_ex(self._ctx, buf, outlen)
self._backend.openssl_assert(res != 0)
self._backend.openssl_assert(outlen[0] == self.algorithm.digest_size)
return self._backend._ffi.buffer(buf)[:outlen[0]]
| {
"content_hash": "4f7c9548ac9ab28f8cee9f059d56e434",
"timestamp": "",
"source": "github",
"line_count": 57,
"max_line_length": 79,
"avg_line_length": 40.92982456140351,
"alnum_prop": 0.5885126446635234,
"repo_name": "zlsun/XX-Net",
"id": "2c8fce1a43c5442c895303d7e060b83c0a5aa515",
"size": "2514",
"binary": false,
"copies": "21",
"ref": "refs/heads/master",
"path": "code/default/python27/1.0/lib/darwin/cryptography/hazmat/backends/openssl/hashes.py",
"mode": "33188",
"license": "bsd-2-clause",
"language": [
{
"name": "Batchfile",
"bytes": "3884"
},
{
"name": "C",
"bytes": "53301"
},
{
"name": "CSS",
"bytes": "86883"
},
{
"name": "HTML",
"bytes": "188948"
},
{
"name": "JavaScript",
"bytes": "6274"
},
{
"name": "Python",
"bytes": "15347559"
},
{
"name": "Shell",
"bytes": "7812"
},
{
"name": "Visual Basic",
"bytes": "1700"
}
],
"symlink_target": ""
} |
"""
Tests of neo.io.asciispiketrainio
"""
# needed for python 3 compatibility
from __future__ import absolute_import, division
import unittest
from neo.io import AsciiSpikeTrainIO
from neo.test.iotest.common_io_test import BaseTestIO
class TestAsciiSpikeTrainIO(BaseTestIO, unittest.TestCase, ):
ioclass = AsciiSpikeTrainIO
files_to_download = ['File_ascii_spiketrain_1.txt']
files_to_test = files_to_download
if __name__ == "__main__":
unittest.main()
| {
"content_hash": "8557b558f109b89019a7a7f1b86ef4b5",
"timestamp": "",
"source": "github",
"line_count": 21,
"max_line_length": 61,
"avg_line_length": 22.666666666666668,
"alnum_prop": 0.7331932773109243,
"repo_name": "rgerkin/python-neo",
"id": "b796ca607e1d88da80e94b3e37010c6c54f1ec54",
"size": "500",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "neo/test/iotest/test_asciispiketrainio.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "Python",
"bytes": "2486594"
}
],
"symlink_target": ""
} |
from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Deleting field 'Culture.abvdcode'
db.delete_column('cultures', 'abvdcode')
def backwards(self, orm):
# Adding field 'Culture.abvdcode'
db.add_column('cultures', 'abvdcode',
self.gf('django.db.models.fields.IntegerField')(null=True, blank=True),
keep_default=False)
models = {
u'auth.group': {
'Meta': {'object_name': 'Group'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
u'auth.permission': {
'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
u'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Group']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Permission']"}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
u'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
u'core.culture': {
'Meta': {'ordering': "['culture']", 'object_name': 'Culture', 'db_table': "'cultures'"},
'added': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'culture': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '128', 'db_index': 'True'}),
'editor': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
'fact': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'languages': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['core.Language']", 'symmetrical': 'False', 'blank': 'True'}),
'notes': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '128'})
},
u'core.language': {
'Meta': {'ordering': "['language']", 'unique_together': "(('isocode', 'language'),)", 'object_name': 'Language', 'db_table': "'languages'"},
'added': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'classification': ('django.db.models.fields.TextField', [], {}),
'editor': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'isocode': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '3', 'db_index': 'True'}),
'language': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'})
},
u'core.section': {
'Meta': {'ordering': "['id']", 'object_name': 'Section', 'db_table': "'sections'"},
'added': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'editor': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'notes': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'section': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '128'})
},
u'core.source': {
'Meta': {'ordering': "['author', 'year']", 'unique_together': "(['author', 'year'],)", 'object_name': 'Source', 'db_table': "'sources'", 'index_together': "[['author', 'year']]"},
'added': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'author': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
'bibtex': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'comment': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'editor': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'reference': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '1000'}),
'year': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'})
}
}
complete_apps = ['core'] | {
"content_hash": "d8f63e7c1e82631c292170816dae67fd",
"timestamp": "",
"source": "github",
"line_count": 101,
"max_line_length": 195,
"avg_line_length": 73.86138613861387,
"alnum_prop": 0.5459785522788204,
"repo_name": "shh-dlce/pulotu",
"id": "b428739fa08df42392b920904cafbf6b6b6895bf",
"size": "7484",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "website/apps/core/migrations/0013_auto__del_field_culture_abvdcode.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "CSS",
"bytes": "56056"
},
{
"name": "HTML",
"bytes": "87074"
},
{
"name": "JavaScript",
"bytes": "348481"
},
{
"name": "Python",
"bytes": "1438334"
}
],
"symlink_target": ""
} |
import code
##
# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
# This file is part of openmano
# 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.
#
# For those usages not covered by the Apache License, Version 2.0 please
# contact with: [email protected]
##
'''
Implement the logic for obtaining compute nodes information
Resource Availability Descriptor
'''
__author__="Pablo Montes"
#TODO: remove warnings, remove unused things
from definitionsClass import definitionsClass
from auxiliary_functions import get_ssh_connection
import libvirt
from xml.etree import ElementTree
import paramiko
import re
import yaml
def getCredentials(creds, data):
"""Used as a backup for libvirt.openAuth in order to provide password that came with data,
not used by the moment
"""
print "RADclass:getCredentials", creds, data
for cred in creds:
print cred[1] + ": ",
if cred[0] == libvirt.VIR_CRED_AUTHNAME:
cred[4] = data
elif cred[0] == libvirt.VIR_CRED_PASSPHRASE:
cred[4] = data
else:
return -1
return 0
class RADclass():
def __init__(self):
self.name = None
self.machine = None
self.user = None
self.password = None
self.nodes = dict() #Dictionary of nodes. Keys are the node id, values are Node() elements
self.nr_processors = None #Integer. Number of processors in the system
self.processor_family = None #If all nodes have the same value equal them, otherwise keep as None
self.processor_manufacturer = None #If all nodes have the same value equal them, otherwise keep as None
self.processor_version = None #If all nodes have the same value equal them, otherwise keep as None
self.processor_features = None #If all nodes have the same value equal them, otherwise keep as None
self.memory_type = None #If all nodes have the same value equal them, otherwise keep as None
self.memory_freq = None #If all nodes have the same value equal them, otherwise keep as None
self.memory_nr_channels = None #If all nodes have the same value equal them, otherwise keep as None
self.memory_size = None #Integer. Sum of the memory in all nodes
self.memory_hugepage_sz = None
self.hypervisor = Hypervisor() #Hypervisor information
self.os = OpSys() #Operating system information
self.ports_list = list() #List containing all network ports in the node. This is used to avoid having defined multiple times the same port in the system
def obtain_RAD(self, user, password, machine):
"""This function obtains the RAD information from the remote server.
It uses both a ssh and a libvirt connection.
It is desirable in future versions get rid of the ssh connection, but currently
libvirt does not provide all the needed information.
Returns (True, Warning) in case of success and (False, <error>) in case of error"""
warning_text=""
try:
#Get virsh and ssh connection
(return_status, code) = get_ssh_connection(machine, user, password)
if not return_status:
print 'RADclass.obtain_RAD() error:', code
return (return_status, code)
ssh_conn = code
self.connection_IP = machine
#print "libvirt open pre"
virsh_conn=libvirt.open("qemu+ssh://"+user+'@'+machine+"/system")
#virsh_conn=libvirt.openAuth("qemu+ssh://"+user+'@'+machine+"/system",
# [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_USERNAME], getCredentials, password],
# 0)
#print "libvirt open after"
# #Set connection infomation
# (return_status, code) = self.set_connection_info(machine, user, password)
# if not return_status:
# return (return_status, 'Error in '+machine+': '+code)
#Set server name
machine_name = get_hostname(virsh_conn)
(return_status, code) = self.set_name(machine_name)
if not return_status:
return (return_status, 'Error at self.set_name in '+machine+': '+code)
warning_text += code
#Get the server processors information
processors = dict()
(return_status, code) = get_processor_information(ssh_conn, virsh_conn, processors)
if not return_status:
return (return_status, 'Error at get_processor_information in '+machine+': '+code)
warning_text += code
#Get the server memory information
memory_nodes = dict()
(return_status, code) = get_memory_information(ssh_conn, virsh_conn, memory_nodes)
if not return_status:
return (return_status, 'Error at get_memory_information in '+machine+': '+code)
warning_text += code
#Get nics information
nic_topology = dict()
# (return_status, code) = get_nic_information_old(ssh_conn, nic_topology)
(return_status, code) = get_nic_information(ssh_conn, virsh_conn, nic_topology)
if not return_status:
return (return_status, 'Error at get_nic_informationin '+machine+': '+code)
warning_text += code
#Pack each processor, memory node and nics in a node element
#and add the node to the RAD element
for socket_id, processor in processors.iteritems():
node = Node()
if not socket_id in nic_topology:
nic_topology[socket_id] = list()
(return_status, code) = node.set(processor, memory_nodes[socket_id], nic_topology[socket_id])
# else:
# (return_status, code) = node.set(processor, memory_nodes[socket_id])
if not return_status:
return (return_status, 'Error at node.set in '+machine+': '+code)
warning_text += code
(return_status, code) = self.insert_node(node)
if not return_status:
return (return_status, 'Error at self.insert_node in '+machine+': '+code)
if code not in warning_text:
warning_text += code
#Fill os data
os = OpSys()
(return_status, code) = get_os_information(ssh_conn, os)
if not return_status:
return (return_status, 'Error at get_os_information in '+machine+': '+code)
warning_text += code
(return_status, code) = self.set_os(os)
if not return_status:
return (return_status, 'Error at self.set_os in '+machine+': '+code)
warning_text += code
#Fill hypervisor data
hypervisor = Hypervisor()
(return_status, code) = get_hypervisor_information(virsh_conn, hypervisor)
if not return_status:
return (return_status, 'Error at get_hypervisor_information in '+machine+': '+code)
warning_text += code
(return_status, code) = self.set_hypervisor(hypervisor)
if not return_status:
return (return_status, 'Error at self.set_hypervisor in '+machine+': '+code)
warning_text += code
ssh_conn.close()
return (True, warning_text)
except libvirt.libvirtError, e:
text = e.get_error_message()
print 'RADclass.obtain_RAD() exception:', text
return (False, text)
except paramiko.ssh_exception.SSHException, e:
text = e.args[0]
print "obtain_RAD ssh Exception:", text
return False, text
def set_name(self,name):
"""Sets the machine name.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(name,str):
return (False, 'The variable \'name\' must be text')
self.name = name
return (True, "")
def set_connection_info(self, machine, user, password):
"""Sets the connection information.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(machine,str):
return (False, 'The variable \'machine\' must be text')
if not isinstance(user,str):
return (False, 'The variable \'user\' must be text')
# if not isinstance(password,str):
# return (False, 'The variable \'password\' must be text')
(self.machine, self.user, self.password) = (machine, user, password)
return (True, "")
def insert_node(self,node):
"""Inserts a new node and updates class variables.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(node,Node):
return (False, 'The variable \'node\' must be a Node element')
if node.id_ in self.nodes:
return (False, 'The node is already present in the nodes list.')
#Check if network ports have not been inserted previously as part of another node
for port_key in node.ports_list:
if port_key in self.ports_list:
return (False, 'Network port '+port_key+' defined multiple times in the system')
self.ports_list.append(port_key)
#Insert the new node
self.nodes[node.id_] = node
#update variables
self.update_variables()
return (True, "")
def update_variables(self):
"""Updates class variables.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
warning_text=""
#The number of processors and nodes is the same
self.nr_processors = len(self.nodes)
#If all processors are the same get the values. Otherwise keep them as none
prev_processor_family = prev_processor_manufacturer = prev_processor_version = prev_processor_features = None
different_processor_family = different_processor_manufacturer = different_processor_version = different_processor_features = False
for node in self.nodes.itervalues():
(self.processor_family, self.processor_manufacturer, self.processor_version, self.processor_features) = node.get_processor_info()
if prev_processor_family != None and self.processor_family != prev_processor_family:
different_processor_family = True
if prev_processor_manufacturer != None and self.processor_manufacturer != prev_processor_manufacturer:
different_processor_manufacturer = True
if prev_processor_version != None and self.processor_version != prev_processor_version:
different_processor_version = True
if prev_processor_features != None and self.processor_features != prev_processor_features:
different_processor_features = True
(prev_processor_family, prev_processor_manufacturer, prev_processor_version, prev_processor_features) = (self.processor_family, self.processor_manufacturer, self.processor_version, self.processor_features)
if different_processor_family:
self.processor_family = None
if different_processor_features:
self.processor_features = None
if different_processor_manufacturer:
self.processor_manufacturer = None
if different_processor_version:
self.processor_version = None
#If all memory nodes are the same get the values. Otherwise keep them as none
#Sum the total memory
self.memory_size = 0
different_memory_freq = different_memory_nr_channels = different_memory_type = different_memory_hugepage_sz = False
prev_memory_freq = prev_memory_nr_channels = prev_memory_type = prev_memory_hugepage_sz = None
for node in self.nodes.itervalues():
(self.memory_freq, self.memory_nr_channels, self.memory_type, memory_size, self.memory_hugepage_sz) = node.get_memory_info()
self.memory_size += memory_size
if prev_memory_freq != None and self.memory_freq != prev_memory_freq:
different_memory_freq = True
if prev_memory_nr_channels != None and self.memory_nr_channels != prev_memory_nr_channels:
different_memory_nr_channels = True
if prev_memory_type != None and self.memory_type != prev_memory_type:
different_memory_type = True
if prev_memory_hugepage_sz != None and self.memory_hugepage_sz != prev_memory_hugepage_sz:
different_memory_hugepage_sz = True
(prev_memory_freq, prev_memory_nr_channels, prev_memory_type, prev_memory_hugepage_sz) = (self.memory_freq, self.memory_nr_channels, self.memory_type, self.memory_hugepage_sz)
if different_memory_freq:
self.memory_freq = None
if different_memory_nr_channels:
self.memory_nr_channels = None
if different_memory_type:
self.memory_type = None
if different_memory_hugepage_sz:
warning_text += 'Detected different hugepages size in different sockets\n'
return (True, warning_text)
def set_hypervisor(self,hypervisor):
"""Sets the hypervisor.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(hypervisor,Hypervisor):
return (False, 'The variable \'hypervisor\' must be of class Hypervisor')
self.hypervisor.assign(hypervisor)
return (True, "")
def set_os(self,os):
"""Sets the operating system.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(os,OpSys):
return (False, 'The variable \'os\' must be of class OpSys')
self.os.assign(os)
return (True, "")
def to_text(self):
text= 'name: '+self.name+'\n'
text+= 'processor:\n'
text+= ' nr_processors: '+str(self.nr_processors)+'\n'
text+= ' family: '+self.processor_family+'\n'
text+= ' manufacturer: '+self.processor_manufacturer+'\n'
text+= ' version: '+self.processor_version+'\n'
text+= ' features: '+str(self.processor_features)+'\n'
text+= 'memory:\n'
text+= ' type: '+self.memory_type+'\n'
text+= ' freq: '+str(self.memory_freq)+'\n'
text+= ' nr_channels: '+str(self.memory_nr_channels)+'\n'
text+= ' size: '+str(self.memory_size)+'\n'
text+= 'hypervisor:\n'
text+= self.hypervisor.to_text()
text+= 'os:\n'
text+= self.os.to_text()
text+= 'resource topology:\n'
text+= ' nr_nodes: '+ str(len(self.nodes))+'\n'
text+= ' nodes:\n'
for node_k, node_v in self.nodes.iteritems():
text+= ' node'+str(node_k)+':\n'
text+= node_v.to_text()
return text
def to_yaml(self):
return yaml.load(self.to_text())
class Node():
def __init__(self):
self.id_ = None #Integer. Node id. Unique in the system
self.processor = ProcessorNode() #Information about the processor in the node
self.memory = MemoryNode() #Information about the memory in the node
self.nic_list = list() #List of Nic() containing information about the nics associated to the node
self.ports_list = list() #List containing all network ports in the node. This is used to avoid having defined multiple times the same port in the system
def get_processor_info(self):
"""Gets the processor information. Returns (processor_family, processor_manufacturer, processor_version, processor_features)"""
return self.processor.get_info()
def get_memory_info(self):
"""Gets the memory information. Returns (memory_freq, memory_nr_channels, memory_type, memory_size)"""
return self.memory.get_info()
# def set(self, *args):
# """Sets the node information. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
# if len(args)==2:
# processor = args[0]
# memory = args[1]
# nics = False
# elif len(args)==3:
# processor = args[0]
# memory = args[1]
# nic_list = args[2]
# nics = True
# else:
# return (False, 'Wrong number of elements calling Node().set()')
def set(self, processor, memory, nic_list):
(status, return_code) = self.processor.assign(processor)
if not status:
return (status, return_code)
self.id_ = processor.id_
(status, return_code) = self.memory.assign(memory)
if not status:
return (status, return_code)
# if nics:
for nic in nic_list:
if not isinstance(nic,Nic):
return (False, 'The nics must be of type Nic')
self.nic_list.append(nic)
for port_key in nic.ports.iterkeys():
if port_key in self.ports_list:
return (False, 'Network port '+port_key+'defined multiple times in the same node')
self.ports_list.append(port_key)
return (True,"")
def assign(self, node):
"""Sets the node information.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
warning_text=""
processor = node.processor
memory = node.memory
nic_list = node.nic_list
(status, return_code) = self.processor.assign(processor)
if not status:
return (status, return_code)
self.id_ = processor.id_
(status, return_code) = self.memory.assign(memory)
if not status:
return (status, return_code)
warning_text += code
for nic in nic_list:
if not isinstance(nic,Nic):
return (False, 'The nics must be of type Nic')
self.nic_list.append(nic)
for port_key in nic.ports.iterkeys():
if port_key in self.ports_list:
return (False, 'Network port '+port_key+'defined multiple times in the same node')
self.ports_list.append(port_key)
return (True,warning_text)
def to_text(self):
text= ' id: '+str(self.id_)+'\n'
text+= ' cpu:\n'
text += self.processor.to_text()
text+= ' memory:\n'
text += self.memory.to_text()
if len(self.nic_list) > 0:
text+= ' nics:\n'
nic_index = 0
for nic in self.nic_list:
text+= ' nic '+str(nic_index)+':\n'
text += nic.to_text()
nic_index += 1
return text
class ProcessorNode():
#Definition of the possible values of processor variables
possible_features = definitionsClass.processor_possible_features
possible_manufacturers = definitionsClass.processor_possible_manufacturers
possible_families = definitionsClass.processor_possible_families
possible_versions = definitionsClass.processor_possible_versions
def __init__(self):
self.id_ = None #Integer. Numeric identifier of the socket
self.family = None #Text. Family name of the processor
self.manufacturer = None #Text. Manufacturer of the processor
self.version = None #Text. Model version of the processor
self.features = list() #list. List of features offered by the processor
self.cores = list() #list. List of cores in the processor. In case of hyperthreading the coupled cores are expressed as [a,b]
self.eligible_cores = list()#list. List of cores that can be used
#self.decicated_cores
#self.shared_cores -> this should also contain information to know if cores are being used
def assign(self, processor):
"""Sets the processor information.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(processor,ProcessorNode):
return (False, 'The variable \'processor\' must be of class ProcessorNode')
self.id_ = processor.id_
self.family = processor.family
self.manufacturer = processor.manufacturer
self.version = processor.version
self.features = processor.features
self.cores = processor.cores
self.eligible_cores = processor.eligible_cores
return (True, "")
def set(self, id_, family, manufacturer, version, features, cores):
"""Sets the processor information.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
warning_text = ""
if not isinstance(id_,int):
return (False, 'The processor id_ must be of type int')
if not isinstance(family,str):
return (False, 'The processor family must be of type str')
if not isinstance(manufacturer,str):
return (False, 'The processor manufacturer must be of type str')
if not isinstance(version,str):
return (False, 'The processor version must be of type str')
if not isinstance(features,list):
return (False, 'The processor features must be of type list')
if not isinstance(cores,list):
return (False, 'The processor cores must be of type list')
(self.id_, self.family, self.manufacturer, self.version) = (id_, family, manufacturer, version)
if not manufacturer in self.possible_manufacturers:
warning_text += "processor manufacturer '%s' not among: %s\n" %(manufacturer, str(self.possible_manufacturers))
if not family in self.possible_families:
warning_text += "family '%s' not among: %s\n" % (family, str(self.possible_families))
# if not version in self.possible_versions:
# warning_text += 'The version %s is not one of these: %s\n' % (version, str(self.possible_versions))
for feature in features:
if not feature in self.possible_features:
warning_text += "processor feature '%s' not among: %s\n" % (feature, str(self.possible_versions))
self.features.append(feature)
#If hyperthreading is active cores must be coupled in the form of [[a,b],[c,d],...]
if 'ht' in self.features:
for iterator in sorted(cores):
if not isinstance(iterator,list) or len(iterator) != 2 or not isinstance(iterator[0],int) or not isinstance(iterator[1],int):
return (False, 'The cores list for an hyperthreaded processor must be coupled in the form of [[a,b],[c,d],...] where a,b,c,d are of type int')
self.cores.append(iterator)
#If hyperthreading is not active the cores are a single list in the form of [a,b,c,d,...]
else:
for iterator in sorted(cores):
if not isinstance(iterator,int):
return (False, 'The cores list for a non hyperthreaded processor must be in the form of [a,b,c,d,...] where a,b,c,d are of type int')
self.cores.append(iterator)
self.set_eligible_cores()
return (True,warning_text)
def set_eligible_cores(self):
"""Set the default eligible cores, this is all cores non used by the host operating system"""
not_first = False
for iterator in self.cores:
if not_first:
self.eligible_cores.append(iterator)
else:
not_first = True
return
def get_info(self):
"""Returns processor parameters (self.family, self.manufacturer, self.version, self.features)"""
return (self.family, self.manufacturer, self.version, self.features)
def to_text(self):
text= ' id: '+str(self.id_)+'\n'
text+= ' family: '+self.family+'\n'
text+= ' manufacturer: '+self.manufacturer+'\n'
text+= ' version: '+self.version+'\n'
text+= ' features: '+str(self.features)+'\n'
text+= ' cores: '+str(self.cores)+'\n'
text+= ' eligible_cores: '+str(self.eligible_cores)+'\n'
return text
class MemoryNode():
def __init__(self):
self.modules = list() #List of MemoryModule(). List of all modules installed in the node
self.nr_channels = None #Integer. Number of modules installed in the node
self.node_size = None #Integer. Total size in KiB of memory installed in the node
self.eligible_memory = None #Integer. Size in KiB of eligible memory in the node
self.hugepage_sz = None #Integer. Size in KiB of hugepages
self.hugepage_nr = None #Integer. Number of hugepages allocated in the module
self.eligible_hugepage_nr = None #Integer. Number of eligible hugepages in the node
self.type_ = None #Text. Type of memory modules. If modules have a different value keep it as None
self.freq = None #Integer. Frequency of the modules in MHz. If modules have a different value keep it as None
self.module_size = None #Integer. Size of the modules in KiB. If modules have a different value keep it as None
self.form_factor = None #Text. Form factor of the modules. If modules have a different value keep it as None
def assign(self, memory_node):
return self.set(memory_node.modules, memory_node.hugepage_sz, memory_node.hugepage_nr)
def set(self, modules, hugepage_sz, hugepage_nr):
"""Set the memory node information. hugepage_sz must be expressed in KiB.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(modules, list):
return (False, 'The modules must be a list of elements of class MemoryModule')
if not isinstance(hugepage_sz,int):
return (False, 'The hugepage_sz variable must be an int expressing the size in KiB')
if not isinstance(hugepage_nr,int):
return (False, 'The hugepage_nr variable must be of type int')
(self.hugepage_sz, self.hugepage_nr) = (hugepage_sz, hugepage_nr)
self.node_size = self.nr_channels = 0
different_type = different_freq = different_module_size = different_form_factor = False
prev_type = prev_freq = prev_module_size = prev_form_factor = None
for iterator in modules:
if not isinstance(iterator,MemoryModule):
return (False, 'The modules must be a list of elements of class MemoryModule')
self.modules.append(iterator)
(self.type_, self.freq, self.module_size, self.form_factor) = (iterator.type_, iterator.freq, iterator.size, iterator.form_factor)
self.node_size += self.module_size
self.nr_channels += 1
if prev_type != None and prev_type != self.type_:
different_type = True
if prev_freq != None and prev_freq != self.freq:
different_freq = True
if prev_module_size != None and prev_module_size != self.module_size:
different_module_size = True
if prev_form_factor != None and prev_form_factor != self.form_factor:
different_form_factor = True
(prev_type, prev_freq, prev_module_size, prev_form_factor) = (self.type_, self.freq, self.module_size, self.form_factor)
if different_type:
self.type_ = None
if different_freq:
self.freq = None
if different_module_size:
self.module_size = None
if different_form_factor:
self.form_factor = None
(return_value, error_code) = self.set_eligible_memory()
if not return_value:
return (return_value, error_code)
return (True, "")
def set_eligible_memory(self):
"""Sets the default eligible_memory and eligible_hugepage_nr. This is all memory but 2GiB and all hugepages"""
self.eligible_memory = self.node_size - 2*1024*1024
if self.eligible_memory < 0:
return (False, "There is less than 2GiB of memory in the module")
self.eligible_hugepage_nr = self.hugepage_nr
return (True,"")
def get_info(self):
"""Return memory information (self.freq, self.nr_channels, self.type_, self.node_size)"""
return (self.freq, self.nr_channels, self.type_, self.node_size, self.hugepage_sz)
def to_text(self):
text= ' node_size: '+str(self.node_size)+'\n'
text+= ' nr_channels: '+str(self.nr_channels)+'\n'
text+= ' eligible_memory: '+str(self.eligible_memory)+'\n'
text+= ' hugepage_sz: '+str(self.hugepage_sz)+'\n'
text+= ' hugepage_nr: '+str(self.hugepage_nr)+'\n'
text+= ' eligible_hugepage_nr: '+str(self.eligible_hugepage_nr)+'\n'
text+= ' type: '+self.type_+'\n'
text+= ' freq: '+str(self.freq)+'\n'
text+= ' module_size: '+str(self.module_size)+'\n'
text+= ' form_factor: '+self.form_factor+'\n'
text+= ' modules details:\n'
for module in self.modules:
text += module.to_text()
return text
class MemoryModule():
#Definition of the possible values of module variables
possible_types = definitionsClass.memory_possible_types
possible_form_factors = definitionsClass.memory_possible_form_factors
def __init__(self):
self.locator = None #Text. Name of the memory module
self.type_ = None #Text. Type of memory module
self.freq = None #Integer. Frequency of the module in MHz
self.size = None #Integer. Size of the module in KiB
self.form_factor = None #Text. Form factor of the module
def set(self, locator, type_, freq, size, form_factor):
"""Sets the memory module information.
Frequency must be expressed in MHz and size in KiB.
Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
warning_text=""
if not isinstance(locator, str):
return (False, "The type of the variable locator must be str")
if not isinstance(type_, str):
return (False, "The type of the variable type_ must be str")
if not isinstance(form_factor, str):
return (False, "The type of the variable form_factor must be str")
if not isinstance(freq, int):
return (False, "The type of the variable freq must be int")
if not isinstance(size, int):
return (False, "The type of the variable size must be int")
if not form_factor in self.possible_form_factors:
warning_text += "memory form_factor '%s' not among: %s\n" %(form_factor, str(self.possible_form_factors))
if not type_ in self.possible_types:
warning_text += "memory type '%s' not among: %s\n" %(type_, str(self.possible_types))
(self.locator, self.type_, self.freq, self.size, self.form_factor) = (locator, type_, freq, size, form_factor)
return (True, warning_text)
def to_text(self):
text= ' '+self.locator+':\n'
text+= ' type: '+self.type_+'\n'
text+= ' freq: '+str(self.freq)+'\n'
text+= ' size: '+str(self.size)+'\n'
text+= ' form factor: '+self.form_factor+'\n'
return text
class Nic():
def __init__(self):
self.model = None #Text. Model of the nic
self.ports = dict() #Dictionary of ports. Keys are the port name, value are Port() elements
def set_model(self, model):
"""Sets the model of the nic. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(model,str):
return (False, 'The \'model\' must be of type str')
self.model = model
return (True, "")
def add_port(self, port):
"""Adds a port to the nic. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
if not isinstance(port,Port):
return (False, 'The \'port\' must be of class Port')
# port_id = str(port.pci_device_id[0])+':'+str(port.pci_device_id[1])+':'+str(port.pci_device_id[2])+'.'+str(port.pci_device_id[3])
#CHANGED
# port_id = port.name
port_id = port.pci_device_id
#CHANGED END
if port_id in self.ports:
return (False, 'The \'port\' '+port.pci_device_id+' is duplicated in the nic')
# return (False, 'The \'port\' is duplicated in the nic')
self.ports[port_id] = port
return (True, "")
def to_text(self):
text= ' model: '+ str(self.model)+'\n'
text+= ' ports: '+'\n'
for key,port in self.ports.iteritems():
text+= ' "'+key+'":'+'\n'
text += port.to_text()
return text
class Port():
def __init__(self):
self.name = None #Text. Port name
self.virtual = None #Boolean. States if the port is a virtual function
self.enabled = None #Boolean. States if the port is enabled
self.eligible = None #Boolean. States if the port is eligible
self.speed = None #Integer. Indicates the speed in Mbps
self.available_bw = None #Integer. BW in Mbps that is available.
self.mac = None #list. Indicates the mac address of the port as a list in format ['XX','XX','XX','XX','XX','XX']
self.pci_device_id_split = None #list. Indicates the pci address of the port as a list in format ['XXXX','XX','XX','X']
self.pci_device_id = None
self.PF_pci_device_id = None
# def set(self, name, virtual, enabled, speed, mac, pci_device_id, pci_device_id_split):
# """Sets the port information. The variable speed indicates the speed in Mbps. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
# if not isinstance(name,str):
# return (False, 'The variable \'name\' must be of type str')
# if not isinstance(virtual,bool):
# return (False, 'The variable \'virtual\' must be of type bool')
# if not isinstance(enabled,bool):
# return (False, 'The variable \'enabled\' must be of type bool')
# if not isinstance(enabled,bool):
# return (speed, 'The variable \'speed\' must be of type int')
# if not isinstance(mac, list) and not isinstance(mac,NoneType):
# return (False, 'The variable \'enabled\' must be of type list indicating the mac address in format [\'XXXX\',\'XX\',\'XX\',\'X\'] or NoneType')
# if not isinstance(pci_device_id_split, list) or len(pci_device_id_split) != 4:
# return (False, 'The variable \'pci_device_id_split\' must be of type list, indicating the pci address in format [\'XX\',\'XX\',\'XX\',\'XX\',\'XX\',\'XX\']')
#
# expected_len = [4,2,2,1]
# index = 0
# for iterator in pci_device_id_split:
# if not isinstance(iterator,str) or not iterator.isdigit() or len(iterator) != expected_len[index]:
# return (False, 'The variable \'pci_device_id_split\' must be of type list, indicating the pci address in format [\'XX\',\'XX\',\'XX\',\'XX\',\'XX\',\'XX\']')
# index += 1
#
# if not isinstance(mac,NoneType):
# for iterator in mac:
# if not isinstance(iterator,str) or not iterator.isalnum() or len(iterator) != 2:
# return (False, 'The variable \'enabled\' must be of type list indicating the mac address in format [\'XXXX\',\'XX\',\'XX\',\'X\'] or NoneType')
#
# #By default only virtual ports are eligible
# # (self.name, self.virtual, self.enabled, self.eligible, self.available_bw, self.speed, self.mac, self.pci_device_id, self.pci_device_id_split) = (name, virtual, enabled, virtual, speed, speed, mac, pci_device_id, pci_device_id_split)
# (self.name, self.virtual, self.enabled, self.eligible, self.available_bw, self.mac, self.pci_device_id, self.pci_device_id_split) = (name, virtual, enabled, virtual, speed, mac, pci_device_id, pci_device_id_split)
def to_text(self):
text= ' pci: "'+ str(self.pci_device_id)+'"\n'
text+= ' virtual: '+ str(self.virtual)+'\n'
if self.virtual:
text+= ' PF_pci_id: "'+self.PF_pci_device_id+'"\n'
text+= ' eligible: '+ str(self.eligible)+'\n'
text+= ' enabled: '+str(self.enabled)+'\n'
text+= ' speed: '+ str(self.speed)+'\n'
text+= ' available bw: '+ str(self.available_bw)+'\n'
text+= ' mac: '+ str(self.mac)+'\n'
text+= ' source_name: '+ str(self.name)+'\n'
return text
class Hypervisor():
#Definition of the possible values of hypervisor variables
possible_types = definitionsClass.hypervisor_possible_types
possible_domain_types = definitionsClass.hypervisor_possible_domain_types
def __init__(self):
self.type_ = None #Text. Hypervisor type_
self.version = None #int. Hypervisor version
self.lib_version = None #int. Libvirt version used to compile hypervisor
self.domains = list() #list. List of all the available domains
def set(self, hypervisor, version, lib_version, domains):
warning_text=""
if not isinstance(hypervisor,str):
return (False, 'The variable type_ must be of type str')
if not isinstance(version,int):
return (False, 'The variable version must be of type int')
if not isinstance(lib_version,int):
return (False, 'The library version must be of type int')
if not isinstance(domains,list):
return (False, 'Domains must be a list of the possible domains as str')
if not hypervisor in self.possible_types:
warning_text += "Hyperpivor '%s' not among: %s\n" % (hypervisor, str(self.possible_types))
valid_domain_found = False
for domain in domains:
if not isinstance(domain,str):
return (False, 'Domains must be a list of the possible domains as str')
if domain in self.possible_domain_types:
valid_domain_found = True
self.domains.append(domain)
if not valid_domain_found:
warning_text += 'No valid domain found among: %s\n' % str(self.possible_domain_types)
(self.version, self.lib_version, self.type_) = (version, lib_version, hypervisor)
return (True, warning_text)
def assign(self, hypervisor):
(self.version, self.lib_version, self.type_) = (hypervisor.version, hypervisor.lib_version, hypervisor.type_)
for domain in hypervisor.domains:
self.domains.append(domain)
return
def to_text(self):
text= ' type: '+self.type_+'\n'
text+= ' version: '+str(self.version)+'\n'
text+= ' libvirt version: '+ str(self.lib_version)+'\n'
text+= ' domains: '+str(self.domains)+'\n'
return text
class OpSys():
#Definition of the possible values of os variables
possible_id = definitionsClass.os_possible_id
possible_types = definitionsClass.os_possible_types
possible_architectures = definitionsClass.os_possible_architectures
def __init__(self):
self.id_ = None #Text. Identifier of the OS. Formed by <Distibutor ID>-<Release>-<Codename>. In linux this can be obtained using lsb_release -a
self.type_ = None #Text. Type of operating system
self.bit_architecture = None #Integer. Architecture
def set(self, id_, type_, bit_architecture):
warning_text=""
if not isinstance(type_,str):
return (False, 'The variable type_ must be of type str')
if not isinstance(id_,str):
return (False, 'The variable id_ must be of type str')
if not isinstance(bit_architecture,str):
return (False, 'The variable bit_architecture must be of type str')
if not type_ in self.possible_types:
warning_text += "os type '%s' not among: %s\n" %(type_, str(self.possible_types))
if not id_ in self.possible_id:
warning_text += "os release '%s' not among: %s\n" %(id_, str(self.possible_id))
if not bit_architecture in self.possible_architectures:
warning_text += "os bit_architecture '%s' not among: %s\n" % (bit_architecture, str(self.possible_architectures))
(self.id_, self.type_, self.bit_architecture) = (id_, type_, bit_architecture)
return (True, warning_text)
def assign(self,os):
(self.id_, self.type_, self.bit_architecture) = (os.id_, os.type_, os.bit_architecture)
return
def to_text(self):
text= ' id: '+self.id_+'\n'
text+= ' type: '+self.type_+'\n'
text+= ' bit_architecture: '+self.bit_architecture+'\n'
return text
def get_hostname(virsh_conn):
return virsh_conn.getHostname().rstrip('\n')
def get_hugepage_size(ssh_conn):
command = 'sudo hugeadm --page-sizes'
# command = 'hugeadm --page-sizes-all'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
mem=stdout.read()
if mem=="":
return 0
return int(mem)
def get_hugepage_nr(ssh_conn,hugepage_sz, node_id):
command = 'cat /sys/devices/system/node/node'+str(node_id)+'/hugepages/hugepages-'+str(hugepage_sz/1024)+'kB/nr_hugepages'
(_, stdout, _) = ssh_conn.exec_command(command)
#print command,
#text = stdout.read()
#print "'"+text+"'"
#return int(text)
try:
value=int(stdout.read())
except:
value=0
return value
def get_memory_information(ssh_conn, virsh_conn, memory_nodes):
warning_text=""
tree=ElementTree.fromstring(virsh_conn.getSysinfo(0))
memory_dict = dict()
for target in tree.findall("memory_device"):
locator_f = size_f = freq_f = type_f = formfactor_f = False
module_form_factor = ""
for entry in target.findall("entry"):
if entry.get("name") == 'size':
size_f = True
size_split = entry.text.split(' ')
if size_split[1] == 'MB':
module_size = int(size_split[0]) * 1024 * 1024
elif size_split[1] == 'GB':
module_size = int(size_split[0]) * 1024 * 1024 * 1024
elif size_split[1] == 'KB':
module_size = int(size_split[0]) * 1024
else:
module_size = int(size_split[0])
elif entry.get("name") == 'speed':
freq_f = True
freq_split = entry.text.split(' ')
if freq_split[1] == 'MHz':
module_freq = int(freq_split[0]) * 1024 * 1024
elif freq_split[1] == 'GHz':
module_freq = int(freq_split[0]) * 1024 * 1024 * 1024
elif freq_split[1] == 'KHz':
module_freq = int(freq_split[0]) * 1024
elif entry.get("name") == 'type':
type_f = True
module_type = entry.text
elif entry.get("name") == 'form_factor':
formfactor_f = True
module_form_factor = entry.text
elif entry.get("name") == 'locator' and not locator_f:
# other case, it is obtained by bank_locator that we give priority to
locator = entry.text
pos = locator.find(module_form_factor)
if module_form_factor == locator[0:len(module_form_factor) ]:
pos = len(module_form_factor) +1
else:
pos = 0
if locator[pos] in "ABCDEFGH":
locator_f = True
node_id = ord(locator[pos])-ord('A')
#print entry.text, node_id
elif entry.get("name") == 'bank_locator':
locator = entry.text
pos = locator.find("NODE ")
if pos >= 0 and len(locator)>pos+5:
if locator[pos+5] in ("01234567"): #len("NODE ") is 5
node_id = int(locator[pos+5])
locator_f = True
#When all module fields have been found add a new module to the list
if locator_f and size_f and freq_f and type_f and formfactor_f:
#If the memory node has not yet been created create it
if node_id not in memory_dict:
memory_dict[node_id] = []
#Add a new module to the memory node
module = MemoryModule()
(return_status, code) = module.set(locator, module_type, module_freq, module_size, module_form_factor)
if not return_status:
return (return_status, code)
memory_dict[node_id].append(module)
if code not in warning_text:
warning_text += code
#Fill memory nodes
#Hugepage size is constant for all nodes
hugepage_sz = get_hugepage_size(ssh_conn)
for node_id, modules in memory_dict.iteritems():
memory_node = MemoryNode()
memory_node.set(modules, hugepage_sz, get_hugepage_nr(ssh_conn,hugepage_sz, node_id))
memory_nodes[node_id] = memory_node
return (True, warning_text)
def get_cpu_topology_ht(ssh_conn, topology):
command = 'cat /proc/cpuinfo'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
sockets = []
cores = []
core_map = {}
core_details = []
core_lines = {}
for line in stdout.readlines():
if len(line.strip()) != 0:
name, value = line.split(":", 1)
core_lines[name.strip()] = value.strip()
else:
core_details.append(core_lines)
core_lines = {}
for core in core_details:
for field in ["processor", "core id", "physical id"]:
if field not in core:
return(False,'Error getting '+field+' value from /proc/cpuinfo')
core[field] = int(core[field])
if core["core id"] not in cores:
cores.append(core["core id"])
if core["physical id"] not in sockets:
sockets.append(core["physical id"])
key = (core["physical id"], core["core id"])
if key not in core_map:
core_map[key] = []
core_map[key].append(core["processor"])
for s in sockets:
hyperthreaded_cores = list()
for c in cores:
hyperthreaded_cores.append(core_map[(s,c)])
topology[s] = hyperthreaded_cores
return (True, "")
def get_processor_information(ssh_conn, vish_conn, processors):
warning_text=""
#Processor features are the same for all processors
#TODO (at least using virsh capabilities)nr_numa_nodes
capabilities = list()
tree=ElementTree.fromstring(vish_conn.getCapabilities())
for target in tree.findall("host/cpu/feature"):
if target.get("name") == 'pdpe1gb':
capabilities.append('lps')
elif target.get("name") == 'dca':
capabilities.append('dioc')
elif target.get("name") == 'vmx' or target.get("name") == 'svm':
capabilities.append('hwsv')
elif target.get("name") == 'ht':
capabilities.append('ht')
target = tree.find("host/cpu/arch")
if target.text == 'x86_64' or target.text == 'amd64':
capabilities.append('64b')
command = 'cat /proc/cpuinfo | grep flags'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
line = stdout.readline()
if 'ept' in line or 'npt' in line:
capabilities.append('tlbps')
#Find out if IOMMU is enabled
command = 'dmesg |grep -e Intel-IOMMU'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
if 'enabled' in stdout.read():
capabilities.append('iommu')
#Equivalent for AMD
command = 'dmesg |grep -e AMD-Vi'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
if len(stdout.read()) > 0:
capabilities.append('iommu')
#-----------------------------------------------------------
topology = dict()
#In case hyperthreading is active it is necessary to determine cpu topology using /proc/cpuinfo
if 'ht' in capabilities:
(return_status, code) = get_cpu_topology_ht(ssh_conn, topology)
if not return_status:
return (return_status, code)
warning_text += code
#Otherwise it is possible to do it using virsh capabilities
else:
for target in tree.findall("host/topology/cells/cell"):
socket_id = int(target.get("id"))
topology[socket_id] = list()
for cpu in target.findall("cpus/cpu"):
topology[socket_id].append(int(cpu.get("id")))
#-----------------------------------------------------------
#Create a dictionary with the information of all processors
#p_fam = p_man = p_ver = None
tree=ElementTree.fromstring(vish_conn.getSysinfo(0))
#print vish_conn.getSysinfo(0)
#return (False, 'forces error for debuging')
not_populated=False
socket_id = -1 #in case we can not determine the socket_id we assume incremental order, starting by 0
for target in tree.findall("processor"):
count = 0
socket_id += 1
#Get processor id, family, manufacturer and version
for entry in target.findall("entry"):
if entry.get("name") == "status":
if entry.text[0:11] == "Unpopulated":
not_populated=True
elif entry.get("name") == 'socket_destination':
socket_text = entry.text
if socket_text.startswith('CPU'):
socket_text = socket_text.strip('CPU')
socket_text = socket_text.strip() #removes trailing spaces
if socket_text.isdigit() and int(socket_text)<9 and int(socket_text)>0:
socket_id = int(socket_text) - 1
elif entry.get("name") == 'family':
family = entry.text
count += 1
elif entry.get("name") == 'manufacturer':
manufacturer = entry.text
count += 1
elif entry.get("name") == 'version':
version = entry.text.strip()
count += 1
if count != 3:
return (False, 'Error. Not all expected fields could be found in processor')
#Create and fill processor structure
if not_populated:
continue #avoid inconsistence of some machines where more socket detected than
processor = ProcessorNode()
(return_status, code) = processor.set(socket_id, family, manufacturer, version, capabilities, topology[socket_id])
if not return_status:
return (return_status, code)
if code not in warning_text:
warning_text += code
#Add processor to the processors dictionary
processors[socket_id] = processor
return (True, warning_text)
def get_nic_information(ssh_conn, virsh_conn, nic_topology):
warning_text=""
#Get list of net devices
net_devices = virsh_conn.listDevices('net',0)
print virsh_conn.listDevices('net',0)
for device in net_devices:
try:
#Get the XML descriptor of the device:
net_XML = ElementTree.fromstring(virsh_conn.nodeDeviceLookupByName(device).XMLDesc(0))
#print "net_XML:" , net_XML
#obtain the parent
parent = net_XML.find('parent')
if parent == None:
print 'No parent was found in XML for device '+device
#Error. continue?-------------------------------------------------------------
continue
if parent.text == 'computer':
continue
if not parent.text.startswith('pci_'):
print device + ' parent is neither computer nor pci'
#Error. continue?-------------------------------------------------------------
continue
interface = net_XML.find('capability/interface').text
mac = net_XML.find('capability/address').text
#Get the pci XML
pci_XML = ElementTree.fromstring(virsh_conn.nodeDeviceLookupByName(parent.text).XMLDesc(0))
#print pci_XML
#Get pci
name = pci_XML.find('name').text.split('_')
pci = name[1]+':'+name[2]+':'+name[3]+'.'+name[4]
#If slot == 0 it is a PF, otherwise it is a VF
capability = pci_XML.find('capability')
if capability.get('type') != 'pci':
print device + 'Capability is not of type pci in '+parent.text
#Error. continue?-------------------------------------------------------------
continue
slot = capability.find('slot').text
bus = capability.find('bus').text
node_id = None
numa_ = capability.find('numa')
if numa_ != None:
node_id = numa_.get('node');
if node_id != None: node_id =int(node_id)
if slot == None or bus == None:
print device + 'Bus and slot not detected in '+parent.text
#Error. continue?-------------------------------------------------------------
continue
if slot != '0':
# print ElementTree.tostring(pci_XML)
virtual = True
capability_pf = capability.find('capability')
if capability_pf.get('type') != 'phys_function':
print 'physical_function not found in VF '+parent.text
#Error. continue?-------------------------------------------------------------
continue
PF_pci = capability_pf.find('address').attrib
PF_pci_text = PF_pci['domain'].split('x')[1]+':'+PF_pci['bus'].split('x')[1]+':'+PF_pci['slot'].split('x')[1]+'.'+PF_pci['function'].split('x')[1]
else:
virtual = False
#Obtain node for the port
if node_id == None:
node_id = int(bus)>>6
#print "node_id:", node_id
#Only for non virtual interfaces: Obtain speed and if link is detected (this must be done using ethtool)
if not virtual:
command = 'sudo ethtool '+interface+' | grep -e Speed -e "Link detected"'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error) >0:
print 'Error running '+command+'\n'+error
#Error. continue?-------------------------------------------------------------
continue
for line in stdout.readlines():
line = line.strip().rstrip('\n').split(': ')
if line[0] == 'Speed':
if line[1].endswith('Mb/s'):
speed = int(line[1].split('M')[0])*int(1e6)
elif line[1].endswith('Gb/s'):
speed = int(line[1].split('G')[0])*int(1e9)
elif line[1].endswith('Kb/s'):
speed = int(line[1].split('K')[0])*int(1e3)
else:
#the interface is listed but won't be used
speed = 0
elif line[0] == 'Link detected':
if line[1] == 'yes':
enabled = True
else:
enabled = False
else:
print 'Unnexpected output of command '+command+':'
print line
#Error. continue?-------------------------------------------------------------
continue
if not node_id in nic_topology:
nic_topology[node_id] = list()
#With this implementation we make the RAD with only one nic per node and this nic has all ports, TODO: change this by including parent information of PF
nic_topology[node_id].append(Nic())
#Load the appropriate nic
nic = nic_topology[node_id][0]
#Create a new port and fill it
port = Port()
port.name = interface
port.virtual = virtual
port.speed = speed
if virtual:
port.available_bw = 0
port.PF_pci_device_id = PF_pci_text
else:
port.available_bw = speed
if speed == 0:
port.enabled = False
else:
port.enabled = enabled
port.eligible = virtual #Only virtual ports are eligible
port.mac = mac
port.pci_device_id = pci
port.pci_device_id_split = name[1:]
#Save the port information
nic.add_port(port)
except Exception,e:
print 'Error: '+str(e)
#set in vitual ports if they are enabled
for nic in nic_topology.itervalues():
for port in nic[0].ports.itervalues():
# print port.pci_device_id
if port.virtual:
enabled = nic[0].ports.get(port.PF_pci_device_id)
if enabled == None:
return(False, 'The PF '+port.PF_pci_device_id+' (VF '+port.pci_device_id+') is not present in ports dict')
#Only if the PF is enabled the VF can be enabled
if nic[0].ports[port.PF_pci_device_id].enabled:
port.enabled = True
else:
port.enabled = False
return (True, warning_text)
def get_nic_information_old(ssh_conn, nic_topology):
command = 'lstopo-no-graphics --of xml'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
tree=ElementTree.fromstring(stdout.read())
for target in tree.findall("object/object"):
#Find numa nodes
if target.get("type") != "NUMANode":
continue
node_id = int(target.get("os_index"))
nic_topology[node_id] = list()
#find nics in numa node
for entry in target.findall("object/object"):
if entry.get("type") != 'Bridge':
continue
nic_name = entry.get("name")
model = None
nic = Nic()
#find ports in nic
for pcidev in entry.findall("object"):
if pcidev.get("type") != 'PCIDev':
continue
enabled = speed = mac = pci_busid = None
port = Port()
model = pcidev.get("name")
virtual = False
if 'Virtual' in model:
virtual = True
pci_busid = pcidev.get("pci_busid")
for osdev in pcidev.findall("object"):
name = osdev.get("name")
for info in osdev.findall("info"):
if info.get("name") != 'Address':
continue
mac = info.get("value")
#get the port speed and status
command = 'sudo ethtool '+name
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
return (False, 'Error obtaining '+name+' information: '+error)
ethtool = stdout.read()
if '10000baseT/Full' in ethtool:
speed = 10e9
elif '1000baseT/Full' in ethtool:
speed = 1e9
elif '100baseT/Full' in ethtool:
speed = 100e6
elif '10baseT/Full' in ethtool:
speed = 10e6
else:
return (False, 'Speed not detected in '+name)
enabled = False
if 'Link detected: yes' in ethtool:
enabled = True
if speed != None and mac != None and pci_busid != None:
mac = mac.split(':')
pci_busid_split = re.split(':|\.', pci_busid)
#Fill the port information
port.set(name, virtual, enabled, speed, mac, pci_busid, pci_busid_split)
nic.add_port(port)
if len(nic.ports) > 0:
#Fill the nic model
if model != None:
nic.set_model(model)
else:
nic.set_model(nic_name)
#Add it to the topology
nic_topology[node_id].append(nic)
return (True, "")
def get_os_information(ssh_conn, os):
warning_text=""
# command = 'lsb_release -a'
# (stdin, stdout, stderr) = ssh_conn.exec_command(command)
# cont = 0
# for line in stdout.readlines():
# line_split = re.split('\t| *', line.rstrip('\n'))
# if line_split[0] == 'Distributor' and line_split[1] == 'ID:':
# distributor = line_split[2]
# cont += 1
# elif line_split[0] == 'Release:':
# release = line_split[1]
# cont += 1
# elif line_split[0] == 'Codename:':
# codename = line_split[1]
# cont += 1
# if cont != 3:
# return (False, 'It was not possible to obtain the OS id')
# id_ = distributor+'-'+release+'-'+codename
command = 'cat /etc/redhat-release'
(_, stdout, _) = ssh_conn.exec_command(command)
id_text= stdout.read()
if len(id_text)==0:
#try with Ubuntu
command = 'lsb_release -d -s'
(_, stdout, _) = ssh_conn.exec_command(command)
id_text= stdout.read()
if len(id_text)==0:
raise paramiko.ssh_exception.SSHException("Can not determinte release neither with 'lsb_release' nor with 'cat /etc/redhat-release'")
id_ = id_text.rstrip('\n')
command = 'uname -o'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
type_ = stdout.read().rstrip('\n')
command = 'uname -i'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error)>0:
raise paramiko.ssh_exception.SSHException(command +' : '+ error)
bit_architecture = stdout.read().rstrip('\n')
(return_status, code) = os.set(id_, type_, bit_architecture)
if not return_status:
return (return_status, code)
warning_text += code
return (True, warning_text)
def get_hypervisor_information(virsh_conn, hypervisor):
type_ = virsh_conn.getType().rstrip('\n')
version = virsh_conn.getVersion()
lib_version = virsh_conn.getLibVersion()
domains = list()
tree=ElementTree.fromstring(virsh_conn.getCapabilities())
for target in tree.findall("guest"):
os_type = target.find("os_type").text
#We only allow full virtualization
if os_type != 'hvm':
continue
wordsize = int(target.find('arch/wordsize').text)
if wordsize == 64:
for domain in target.findall("arch/domain"):
domains.append(domain.get("type"))
(return_status, code) = hypervisor.set(type_, version, lib_version, domains)
if not return_status:
return (return_status, code)
return (True, code)
class RADavailableResourcesClass(RADclass):
def __init__(self, resources):
"""Copy resources from the RADclass (server resources not taking into account resources used by VMs"""
#New
self.reserved = dict() #Dictionary of reserved resources for a server. Key are VNFC names and values RADreservedResources
self.cores_consumption = None #Dictionary of cpu consumption. Key is the cpu and the value is
self.machine = resources.machine
self.user = resources.user
self.password = resources.password
self.name = resources.name
self.nr_processors = resources.nr_processors
self.processor_family = resources.processor_family
self.processor_manufacturer = resources.processor_manufacturer
self.processor_version = resources.processor_version
self.processor_features = resources.processor_features
self.memory_type = resources.memory_type
self.memory_freq = resources.memory_freq
self.memory_nr_channels = resources.memory_nr_channels
self.memory_size = resources.memory_size
self.memory_hugepage_sz = resources.memory_hugepage_sz
self.hypervisor = Hypervisor()
self.hypervisor.assign(resources.hypervisor)
self.os = OpSys()
self.os.assign(resources.os)
self.nodes = dict()
for node_k, node_v in resources.nodes.iteritems():
self.nodes[node_k] = Node()
self.nodes[node_k].assign(node_v)
return
def _get_cores_consumption_warnings(self):
"""Returns list of warning strings in case warnings are generated.
In case no warnings are generated the return value will be an empty list"""
warnings = list()
#Get the cores consumption
(return_status, code) = get_ssh_connection(self.machine, self.user, self.password)
if not return_status:
return (return_status, code)
ssh_conn = code
command = 'mpstat -P ALL 1 1 | grep Average | egrep -v CPU\|all'
(_, stdout, stderr) = ssh_conn.exec_command(command)
error = stderr.read()
if len(error) > 0:
return (False, error)
self.cores_consumption = dict()
for line in stdout.readlines():
cpu_usage_split = re.split('\t| *', line.rstrip('\n'))
usage = 100 *(1 - float(cpu_usage_split[10]))
if usage > 0:
self.cores_consumption[int(cpu_usage_split[1])] = usage
ssh_conn.close()
#Check if any core marked as available in the nodes has cpu_usage > 0
for _, node_v in self.nodes.iteritems():
cores = node_v.processor.eligible_cores
for cpu in cores:
if len(cpu) > 1:
for core in cpu:
if core in self.cores_consumption:
warnings.append('Warning: Core '+str(core)+' is supposed to be idle but it is consuming '+str(self.cores_consumption[core])+'%')
else:
if cpu in self.cores_consumption:
warnings.append('Warning: Core '+str(core)+' is supposed to be idle but it is consuming '+str(self.cores_consumption[cpu])+'%')
return warnings
def reserved_to_text(self):
text = str()
for VNFC_name, VNFC_reserved in self.reserved.iteritems():
text += ' VNFC: '+str(VNFC_name)+'\n'
text += VNFC_reserved.to_text()
return text
def obtain_usage(self):
resp = dict()
#Iterate through nodes to get cores, eligible cores, memory and physical ports (save ports usage for next section)
nodes = dict()
ports_usage = dict()
hugepage_size = dict()
for node_k, node_v in self.nodes.iteritems():
node = dict()
ports_usage[node_k] = dict()
eligible_cores = list()
for pair in node_v.processor.eligible_cores:
if isinstance(pair, list):
for element in pair:
eligible_cores.append(element)
else:
eligible_cores.append(pair)
node['cpus'] = {'cores':node_v.processor.cores,'eligible_cores':eligible_cores}
node['memory'] = {'size':str(node_v.memory.node_size/(1024*1024*1024))+'GB','eligible':str(node_v.memory.eligible_memory/(1024*1024*1024))+'GB'}
hugepage_size[node_k] = node_v.memory.hugepage_sz
ports = dict()
for nic in node_v.nic_list:
for port in nic.ports.itervalues():
if port.enabled and not port.virtual:
ports[port.name] = {'speed':str(port.speed/1000000000)+'G'}
# print '*************** ',port.name,'speed',port.speed
ports_usage[node_k][port.name] = 100 - int(100*float(port.available_bw)/float(port.speed))
node['ports'] = ports
nodes[node_k] = node
resp['RAD'] = nodes
#Iterate through reserved section to get used cores, used memory and port usage
cores = dict()
memory = dict()
#reserved_cores = list
for node_k in self.nodes.iterkeys():
if not node_k in cores:
cores[node_k] = list()
memory[node_k] = 0
for _, reserved in self.reserved.iteritems():
if node_k in reserved.node_reserved_resources:
node_v = reserved.node_reserved_resources[node_k]
cores[node_k].extend(node_v.reserved_cores)
memory[node_k] += node_v.reserved_hugepage_nr * hugepage_size[node_k]
occupation = dict()
for node_k in self.nodes.iterkeys():
ports = dict()
for name, usage in ports_usage[node_k].iteritems():
ports[name] = {'occupied':str(usage)+'%'}
# print '****************cores',cores
# print '****************memory',memory
occupation[node_k] = {'cores':cores[node_k],'memory':str(memory[node_k]/(1024*1024*1024))+'GB','ports':ports}
resp['occupation'] = occupation
return resp
class RADreservedResources():
def __init__(self):
self.node_reserved_resources = dict() #dict. keys are the RAD nodes id, values are NodeReservedResources
self.mgmt_interface_pci = None #pci in the VNF for the management interface
self.image = None #Path in remote machine of the VNFC image
def update(self,reserved):
self.image = reserved.image
self.mgmt_interface_pci = reserved.mgmt_interface_pci
for k,v in reserved.node_reserved_resources.iteritems():
if k in self.node_reserved_resources.keys():
return (False, 'Duplicated node entry '+str(k)+' in reserved resources')
self.node_reserved_resources[k]=v
return (True, "")
def to_text(self):
text = ' image: '+str(self.image)+'\n'
for node_id, node_reserved in self.node_reserved_resources.iteritems():
text += ' Node ID: '+str(node_id)+'\n'
text += node_reserved.to_text()
return text
class NodeReservedResources():
def __init__(self):
# reserved_shared_cores = None #list. List of all cores that the VNFC needs in shared mode #TODO Not used
# reserved_memory = None #Integer. Amount of KiB needed by the VNFC #TODO. Not used since hugepages are used
self.reserved_cores = list() #list. List of all cores that the VNFC uses
self.reserved_hugepage_nr = 0 #Integer. Number of hugepages needed by the VNFC
self.reserved_ports = dict() #dict. The key is the physical port pci and the value the VNFC port description
self.vlan_tags = dict()
self.cpu_pinning = None
def to_text(self):
text = ' cores: '+str(self.reserved_cores)+'\n'
text += ' cpu_pinning: '+str(self.cpu_pinning)+'\n'
text += ' hugepages_nr: '+str(self.reserved_hugepage_nr)+'\n'
for port_pci, port_description in self.reserved_ports.iteritems():
text += ' port: '+str(port_pci)+'\n'
text += port_description.to_text()
return text
# def update(self,reserved):
# self.reserved_cores = list(reserved.reserved_cores)
# self.reserved_hugepage_nr = reserved.reserved_hugepage_nr
# self.reserved_ports = dict(reserved.reserved_ports)
# self.cpu_pinning = list(reserved.cpu_pinning)
| {
"content_hash": "ba6e90e533b895522e195f5014cc4c0b",
"timestamp": "",
"source": "github",
"line_count": 1620,
"max_line_length": 244,
"avg_line_length": 47.42345679012346,
"alnum_prop": 0.5566344727045531,
"repo_name": "me-ankur/openmano",
"id": "7d0ccac99606f0a546335d2c7043110845fad00a",
"size": "76852",
"binary": false,
"copies": "3",
"ref": "refs/heads/master",
"path": "openvim/utils/RADclass.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "CSS",
"bytes": "10986"
},
{
"name": "HTML",
"bytes": "523"
},
{
"name": "JavaScript",
"bytes": "307304"
},
{
"name": "PHP",
"bytes": "69095"
},
{
"name": "PLpgSQL",
"bytes": "41348"
},
{
"name": "Python",
"bytes": "859995"
},
{
"name": "Shell",
"bytes": "187480"
}
],
"symlink_target": ""
} |
import time
from weakref import ref
class Engines(object):
"""
Static collector for engines to register against.
"""
def __init__(self):
self._engines = {}
def register(self, engine):
self._engines[engine.__name__] = engine
self._engines[engine.name] = engine
def __getitem__(self, key):
return self._engines[key]
def __contains__(self, key):
return self._engines.__contains__(key)
Engines = Engines()
class CacheEngineType(type):
"""
Cache Engine Metaclass that registers new engines against the cache
for named selection and use.
"""
def __init__(cls, name, bases, attrs):
super(CacheEngineType, cls).__init__(name, bases, attrs)
if name != 'CacheEngine':
# skip base class
Engines.register(cls)
class CacheEngine(object):
__metaclass__ = CacheEngineType
name = 'unspecified'
def __init__(self, parent):
self.parent = ref(parent)
def configure(self):
raise RuntimeError
def get(self, date):
raise RuntimeError
def put(self, key, value, lifetime):
raise RuntimeError
def expire(self, key):
raise RuntimeError
class CacheObject(object):
"""
Cache object class, containing one stored record.
"""
def __init__(self, key, data, lifetime=0, creation=None):
self.key = key
self.data = data
self.lifetime = lifetime
self.creation = creation if creation is not None else time.time()
def __len__(self):
return len(self.data)
@property
def expired(self):
return self.remaining == 0
@property
def remaining(self):
return max((self.creation + self.lifetime) - time.time(), 0)
| {
"content_hash": "3b884c3e0de35570440bcafe0e5b0458",
"timestamp": "",
"source": "github",
"line_count": 75,
"max_line_length": 73,
"avg_line_length": 23.626666666666665,
"alnum_prop": 0.6032731376975169,
"repo_name": "wagnerrp/pytmdb3",
"id": "11019551cbf3ce8d5c84c169a1ff4ec321808023",
"size": "2004",
"binary": false,
"copies": "34",
"ref": "refs/heads/master",
"path": "tmdb3/cache_engine.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "Python",
"bytes": "111996"
}
],
"symlink_target": ""
} |
"""
Input file writer for SES3D 4.0.
:copyright:
Lion Krischer ([email protected]), 2013
:license:
GNU General Public License, Version 3
(http://www.gnu.org/copyleft/gpl.html)
"""
EARTH_RADIUS = 6371 * 1000
import numpy as np
import obspy
import os
from wfs_input_generator import rotations
# Define the required configuration items. The key is always the name of the
# configuration item and the value is a tuple. The first item in the tuple is
# the function or type that it will be converted to and the second is the
# documentation.
REQUIRED_CONFIGURATION = {
"output_folder": (str, "The output directory"),
"number_of_time_steps": (int, "The number of time steps"),
"time_increment_in_s": (float, "The time increment in seconds"),
"mesh_min_latitude": (float, "The minimum latitude of the mesh"),
"mesh_max_latitude": (float, "The maximum latitude of the mesh"),
"mesh_min_longitude": (float, "The minimum longitude of the mesh"),
"mesh_max_longitude": (float, "The maximum longitude of the mesh"),
"mesh_min_depth_in_km": (float, "The minimum depth of the mesh in km"),
"mesh_max_depth_in_km": (float, "The maximum depth of the mesh in km"),
"nx_global": (int, "Number of elements in theta directions. Please refer "
"to the SES3D manual for a more extensive description"),
"ny_global": (int, "Number of elements in phi directions. Please refer "
"to the SES3D manual for a more extensive description"),
"nz_global": (int, "Number of elements in r directions. Please refer "
"to the SES3D manual for a more extensive description"),
"px": (int, "Number of processors in theta direction"),
"py": (int, "Number of processors in phi direction"),
"pz": (int, "Number of processors in r direction"),
"source_time_function": (np.array, "The source time function.")
}
# The default configuration item. Contains everything that can sensibly be set
# to some default value. The syntax is very similar to the
# REQUIRED_CONFIGURATION except that the tuple now has three items, the first
# one being the actual default value.
DEFAULT_CONFIGURATION = {
"event_tag": ("1", str, "The name of the event. Should be numeric for "
"now."),
"is_dissipative": (True, bool, "Dissipative simulation or not"),
"output_displacement": (False, bool, "Output the displacement field"),
"displacement_snapshot_sampling": (
10000, int, "Sampling rate of output displacement field"),
"lagrange_polynomial_degree": (
4, int, "Degree of the Lagrange Polynomials"),
"simulation_type": (
"normal simulation", str, "The type of simulation to "
"perform. One of 'normal simulation', 'adjoint forward', "
"'adjoint backward'"),
"adjoint_forward_sampling_rate": (
15, int, "The sampling rate of the adjoint forward field for an "
"adjoint simulation run"),
"adjoint_forward_wavefield_output_folder": (
"", str, "The output folder of the adjoint forward field if "
"requested. If empty, it will be set to a subfolder of the the output "
"directory."),
"rotation_angle_in_degree": (
0.0, float, "A possible rotation of the mesh. All data will be "
"rotated in the opposite way. Useful for simulation close to the "
"equator."),
"rotation_axis": (
[0.0, 0.0, 1.0], lambda x: map(float, x),
"The rotation angle given as [x, y, z] in correspondance with the "
"SES3D coordinate system."),
"Q_model_relaxation_times": (
[1.7308, 14.3961, 22.9973],
lambda x: map(float, x),
"The relaxations times for the different Q model mechanisms"),
"Q_model_weights_of_relaxation_mechanisms": (
[2.5100, 2.4354, 0.0879],
lambda x: map(float, x),
"The weights for relaxations mechanisms for the Q model mechanisms")
}
def write(config, events, stations):
"""
Writes input files for SES3D version 4.0.
Can only simulate one event at a time. If more events are present, an error
will be raised.
"""
# ========================================================================
# preliminaries
# ========================================================================
if not config.adjoint_forward_wavefield_output_folder:
config.adjoint_forward_wavefield_output_folder = \
os.path.join(config.output_folder, "ADJOINT_FORWARD_FIELD")
output_files = {}
# The data needs to be rotated in the opposite direction.
if config.rotation_angle_in_degree:
config.rotation_angle_in_degree *= -1.0
# Map and assert the simulation type.
sim_map = {"normal simulation": 0, "adjoint forward": 1,
"adjoint reverse": 2}
if config.simulation_type not in sim_map:
msg = "simulation_type needs to be on of %s." % \
", ".join(sim_map.keys())
raise ValueError(msg)
simulation_type = sim_map[config.simulation_type]
# Only exactly one event is acceptable.
if len(events) != 1:
msg = "Exactly one event is required for SES3D 4.0."
raise ValueError(msg)
event = events[0]
# ========================================================================
# setup file
# =========================================================================
# Assemble the mesh to have everything in one place
mesh = obspy.core.AttribDict()
mesh.min_latitude = config.mesh_min_latitude
mesh.max_latitude = config.mesh_max_latitude
mesh.min_longitude = config.mesh_min_longitude
mesh.max_longitude = config.mesh_max_longitude
mesh.min_depth_in_km = config.mesh_min_depth_in_km
mesh.max_depth_in_km = config.mesh_max_depth_in_km
# Rotate coordinates and moment tensor if requested.
if config.rotation_angle_in_degree:
lat, lng = rotations.rotate_lat_lon(
event["latitude"],
event["longitude"], config.rotation_axis,
config.rotation_angle_in_degree)
m_rr, m_tt, m_pp, m_rt, m_rp, m_tp = rotations.rotate_moment_tensor(
event["m_rr"], event["m_tt"], event["m_pp"], event["m_rt"],
event["m_rp"], event["m_tp"], event["latitude"],
event["longitude"], config.rotation_axis,
config.rotation_angle_in_degree)
else:
lat, lng = (event["latitude"], event["longitude"])
m_rr, m_tt, m_pp, m_rt, m_rp, m_tp = (
event["m_rr"], event["m_tt"], event["m_pp"], event["m_rt"],
event["m_rp"], event["m_tp"])
# Check if the event still lies within bounds. Otherwise the whole
# simulation does not make much sense.
if _is_in_bounds(lat, lng, mesh) is False:
msg = "Event is not in the domain!"
raise ValueError(msg)
setup_file_template = (
"MODEL ==============================================================="
"================================================================="
"=====\n"
"{theta_min:<44.6f}! theta_min (colatitude) in degrees\n"
"{theta_max:<44.6f}! theta_max (colatitude) in degrees\n"
"{phi_min:<44.6f}! phi_min (longitude) in degrees\n"
"{phi_max:<44.6f}! phi_max (longitude) in degrees\n"
"{z_min:<44.6f}! z_min (radius) in m\n"
"{z_max:<44.6f}! z_max (radius) in m\n"
"{is_diss:<44d}! is_diss\n"
"{model_type:<44d}! model_type\n"
"COMPUTATIONAL SETUP (PARALLELISATION) ==============================="
"================================================================="
"=====\n"
"{nx_global:<44d}! nx_global, "
"(nx_global+px = global # elements in theta direction)\n"
"{ny_global:<44d}! ny_global, "
"(ny_global+py = global # elements in phi direction)\n"
"{nz_global:<44d}! nz_global, "
"(nz_global+pz = global # of elements in r direction)\n"
"{lpd:<44d}! lpd, LAGRANGE polynomial degree\n"
"{px:<44d}! px, processors in theta direction\n"
"{py:<44d}! py, processors in phi direction\n"
"{pz:<44d}! pz, processors in r direction\n"
"ADJOINT PARAMETERS =================================================="
"================================================================="
"=====\n"
"{adjoint_flag:<44d}! adjoint_flag (0=normal simulation, "
"1=adjoint forward, 2=adjoint reverse)\n"
"{samp_ad:<44d}! samp_ad, sampling rate of forward field\n"
"{adjoint_wavefield_folder}")
setup_file = setup_file_template.format(
# Colatitude! Swaps min and max.
theta_min=rotations.lat2colat(float(mesh.max_latitude)),
theta_max=rotations.lat2colat(float(mesh.min_latitude)),
phi_min=float(mesh.min_longitude),
phi_max=float(mesh.max_longitude),
# Min/max radius and depth are inverse to each other.
z_min=EARTH_RADIUS - (float(mesh.max_depth_in_km) * 1000.0),
z_max=EARTH_RADIUS - (float(mesh.min_depth_in_km) * 1000.0),
is_diss=1 if config.is_dissipative else 0,
model_type=1,
lpd=int(config.lagrange_polynomial_degree),
# Computation setup.
nx_global=config.nx_global,
ny_global=config.ny_global,
nz_global=config.nz_global,
px=config.px,
py=config.py,
pz=config.pz,
adjoint_flag=simulation_type,
samp_ad=config.adjoint_forward_sampling_rate,
adjoint_wavefield_folder=config
.adjoint_forward_wavefield_output_folder)
output_files["setup"] = setup_file
# =========================================================================
# event file
# =========================================================================
event_template = (
"SIMULATION PARAMETERS ==============================================="
"===================================\n"
"{nt:<44d}! nt, number of time steps\n"
"{dt:<44.6f}! dt in sec, time increment\n"
"SOURCE =============================================================="
"===================================\n"
"{xxs:<44.6f}! xxs, theta-coord. center of source in degrees\n"
"{yys:<44.6f}! yys, phi-coord. center of source in degrees\n"
"{zzs:<44.6f}! zzs, source depth in (m)\n"
"{srctype:<44d}! srctype, 1:f_x, 2:f_y, 3:f_z, 10:M_ij\n"
"{m_tt:<44.6e}! M_theta_theta\n"
"{m_pp:<44.6e}! M_phi_phi\n"
"{m_rr:<44.6e}! M_r_r\n"
"{m_tp:<44.6e}! M_theta_phi\n"
"{m_tr:<44.6e}! M_theta_r\n"
"{m_pr:<44.6e}! M_phi_r\n"
"OUTPUT DIRECTORY ===================================================="
"==================================\n"
"{output_folder}\n"
"OUTPUT FLAGS ========================================================"
"==================================\n"
"{ssamp:<44d}! ssamp, snapshot sampling\n"
"{output_displacement:<44d}! output_displacement, output displacement "
"field (1=yes,0=no)")
event_file = event_template.format(
nt=int(config.number_of_time_steps),
dt=float(config.time_increment_in_s),
# Colatitude!
xxs=rotations.lat2colat(float(lat)),
yys=float(lng),
zzs=float(event["depth_in_km"] * 1000.0),
srctype=10,
m_tt=float(m_tt),
m_pp=float(m_pp),
m_rr=float(m_rr),
m_tp=float(m_tp),
m_tr=float(m_rt),
m_pr=float(m_rp),
output_folder=config.output_folder,
ssamp=int(config.displacement_snapshot_sampling),
output_displacement=1 if config.output_displacement else 0)
# Put it in the collected dictionary.
fn = "event_%s" % config.event_tag
output_files[fn] = event_file
# =========================================================================
# event_list
# =========================================================================
# Make the event_list. Currently, only one event is used
output_files["event_list"] = "{0:<44d}! n_events = number of events\n{1}"\
.format(1, config.event_tag)
# =========================================================================
# recfile
# =========================================================================
recfile_parts = []
for station in stations:
# Also rotate each station if desired.
if config.rotation_angle_in_degree:
lat, lng = rotations.rotate_lat_lon(
station["latitude"], station["longitude"],
config.rotation_axis, config.rotation_angle_in_degree)
else:
lat, lng = (station["latitude"], station["longitude"])
# Check if the stations still lies within bounds of the mesh.
if not _is_in_bounds(lat, lng, mesh):
msg = "Stations %s is not in the domain. Will be skipped." % \
station["id"]
print msg
continue
depth = -1.0 * (station["elevation_in_m"] -
station["local_depth_in_m"])
if depth < 0:
depth = 0.0
recfile_parts.append("{network:_<2s}.{station:_<5s}.___".format(
network=station["id"].split(".")[0],
station=station["id"].split(".")[1]))
recfile_parts.append(
"{colatitude:.6f} {longitude:.6f} {depth:.1f}"
.format(colatitude=rotations.lat2colat(float(lat)),
longitude=float(lng), depth=float(depth)))
recfile_parts.insert(0, "%i" % (len(recfile_parts) // 2))
# Put it in the collected dictionary
fn = "recfile_" + config.event_tag
output_files[fn] = "\n".join(recfile_parts)
# =========================================================================
# relaxation parameters
# =========================================================================
# Write the relaxation file.
relax_file = (
"RELAXATION TIMES [s] =====================\n"
"{relax_times}\n"
"WEIGHTS OF RELAXATION MECHANISMS =========\n"
"{relax_weights}").format(
relax_times="\n".join(["%.6f" % _i for _i in
config.Q_model_relaxation_times]),
relax_weights="\n".join([
"%.6f" % _i for _i in
config.Q_model_weights_of_relaxation_mechanisms]))
output_files["relax"] = relax_file
# =========================================================================
# source-time function
# =========================================================================
# Also write the source time function.
output_files["stf"] = "\n".join(["%e" % _i for
_i in config.source_time_function])
# =========================================================================
# finalize
# =========================================================================
# Make sure all output files have an empty new line at the end.
for key in output_files.iterkeys():
output_files[key] += "\n\n"
return output_files
def _is_in_bounds(lat, lng, mesh):
if (mesh.min_latitude <= lat <= mesh.max_latitude) and \
(mesh.min_longitude <= lng <= mesh.max_longitude):
return True
return False
| {
"content_hash": "42b74ccdca76a83de7dc62050d26feac",
"timestamp": "",
"source": "github",
"line_count": 357,
"max_line_length": 79,
"avg_line_length": 43.182072829131656,
"alnum_prop": 0.5212765957446809,
"repo_name": "rafiqsaleh/VERCE",
"id": "510746e30d928bd4d0bf18714e1cd1e642703fe1",
"size": "15462",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "verce-hpc-pe/src/wfs_input_generator/backends/write_ses3d_4_0.py",
"mode": "33261",
"license": "mit",
"language": [
{
"name": "Batchfile",
"bytes": "3310"
},
{
"name": "CSS",
"bytes": "205682"
},
{
"name": "HTML",
"bytes": "282663"
},
{
"name": "Java",
"bytes": "716231"
},
{
"name": "JavaScript",
"bytes": "10335428"
},
{
"name": "Makefile",
"bytes": "2325"
},
{
"name": "Python",
"bytes": "3426039"
},
{
"name": "Shell",
"bytes": "121346"
},
{
"name": "TeX",
"bytes": "278086"
}
],
"symlink_target": ""
} |
"""Add is_draft status to queries and dashboards
Revision ID: 65fc9ede4746
Revises:
Create Date: 2016-12-07 18:08:13.395586
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
from sqlalchemy.exc import ProgrammingError
revision = '65fc9ede4746'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
try:
op.add_column('queries', sa.Column('is_draft', sa.Boolean, default=True, index=True))
op.add_column('dashboards', sa.Column('is_draft', sa.Boolean, default=True, index=True))
op.execute("UPDATE queries SET is_draft = (name = 'New Query')")
op.execute("UPDATE dashboards SET is_draft = false")
except ProgrammingError as e:
# The columns might exist if you ran the old migrations.
if 'column "is_draft" of relation "queries" already exists' in e.message:
print "Can't run this migration as you already have is_draft columns, please run:"
print "./manage.py db stamp {} # you might need to alter the command to match your environment.".format(revision)
exit()
def downgrade():
op.drop_column('queries', 'is_draft')
op.drop_column('dashboards', 'is_draft')
| {
"content_hash": "fa4555d11b008a88d22291201d54a5c5",
"timestamp": "",
"source": "github",
"line_count": 36,
"max_line_length": 125,
"avg_line_length": 34.138888888888886,
"alnum_prop": 0.6834825061025224,
"repo_name": "luozhanxin/redash-docker",
"id": "91398a1574ddaea6162b96ce2e6e4e17673688e2",
"size": "1229",
"binary": false,
"copies": "9",
"ref": "refs/heads/master",
"path": "migrations/versions/65fc9ede4746_add_is_draft_status_to_queries_and_.py",
"mode": "33188",
"license": "bsd-2-clause",
"language": [
{
"name": "CSS",
"bytes": "225811"
},
{
"name": "HTML",
"bytes": "119914"
},
{
"name": "JavaScript",
"bytes": "251613"
},
{
"name": "Makefile",
"bytes": "825"
},
{
"name": "Mako",
"bytes": "494"
},
{
"name": "Python",
"bytes": "631646"
},
{
"name": "Shell",
"bytes": "41870"
}
],
"symlink_target": ""
} |
from django.apps import AppConfig
class CompanyConfig(AppConfig):
name = 'company'
verbose_name = 'Company'
| {
"content_hash": "6e6a87c4c9866eedeb10b02f123ae226",
"timestamp": "",
"source": "github",
"line_count": 6,
"max_line_length": 33,
"avg_line_length": 19.666666666666668,
"alnum_prop": 0.7203389830508474,
"repo_name": "roks0n/nomadboard",
"id": "7cd18217481c256a1c6621c1c95e4029ebaff436",
"size": "118",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "nomadboard/nomadboard/company/apps.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "79788"
},
{
"name": "HTML",
"bytes": "3798"
},
{
"name": "JavaScript",
"bytes": "90864"
},
{
"name": "Makefile",
"bytes": "1517"
},
{
"name": "Python",
"bytes": "32746"
},
{
"name": "Shell",
"bytes": "231"
}
],
"symlink_target": ""
} |
import os
import json
import datetime
from django import forms
from django.conf import settings
from django.db import transaction
from django.db import models
from apps.game.models import Game
from apps.team.models import Team
from django.contrib.auth.models import User
import utils.files.logics as fileLogics
import copy
| {
"content_hash": "7373e14a1f924ee48a19aa18b7ec238a",
"timestamp": "",
"source": "github",
"line_count": 14,
"max_line_length": 45,
"avg_line_length": 23.571428571428573,
"alnum_prop": 0.8212121212121212,
"repo_name": "zWingz/webbasketball",
"id": "a65b559e2134f7f370eb1834ed83f061fd3aaad2",
"size": "354",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "apps/admin/logics.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "50498"
},
{
"name": "HTML",
"bytes": "170566"
},
{
"name": "JavaScript",
"bytes": "30741"
},
{
"name": "Python",
"bytes": "106971"
}
],
"symlink_target": ""
} |
import sys
import time
import numpy as np
import pytest
import ray
from ray.test_utils import get_other_nodes
import ray.ray_constants as ray_constants
@pytest.mark.skip(reason="No reconstruction for objects placed in plasma yet")
@pytest.mark.parametrize(
"ray_start_cluster",
[{
# Force at least one task per node.
"num_cpus": 1,
"num_nodes": 4,
"object_store_memory": 1000 * 1024 * 1024,
"_system_config": {
# Raylet codepath is not stable with a shorter timeout.
"num_heartbeats_timeout": 10,
"object_manager_pull_timeout_ms": 1000,
"object_manager_push_timeout_ms": 1000,
},
}],
indirect=True)
def test_object_reconstruction(ray_start_cluster):
cluster = ray_start_cluster
# Submit tasks with dependencies in plasma.
@ray.remote
def large_value():
# Sleep for a bit to force tasks onto different nodes.
time.sleep(0.1)
return np.zeros(10 * 1024 * 1024)
@ray.remote
def g(x):
return
# Kill the component on all nodes except the head node as the tasks
# execute. Do this in a loop while submitting tasks between each
# component failure.
time.sleep(0.1)
worker_nodes = get_other_nodes(cluster)
assert len(worker_nodes) > 0
component_type = ray_constants.PROCESS_TYPE_RAYLET
for node in worker_nodes:
process = node.all_processes[component_type][0].process
# Submit a round of tasks with many dependencies.
num_tasks = len(worker_nodes)
xs = [large_value.remote() for _ in range(num_tasks)]
# Wait for the tasks to complete, then evict the objects from the local
# node.
for x in xs:
ray.get(x)
ray.internal.free([x], local_only=True)
# Kill a component on one of the nodes.
process.terminate()
time.sleep(1)
process.kill()
process.wait()
assert not process.poll() is None
# Make sure that we can still get the objects after the
# executing tasks died.
print("F", xs)
xs = [g.remote(x) for x in xs]
print("G", xs)
ray.get(xs)
@pytest.mark.parametrize(
"ray_start_cluster", [{
"num_cpus": 4,
"num_nodes": 3,
"do_init": True
}],
indirect=True)
def test_actor_creation_node_failure(ray_start_cluster):
# TODO(swang): Refactor test_raylet_failed, etc to reuse the below code.
cluster = ray_start_cluster
@ray.remote
class Child:
def __init__(self, death_probability):
self.death_probability = death_probability
def ping(self):
# Exit process with some probability.
exit_chance = np.random.rand()
if exit_chance < self.death_probability:
sys.exit(-1)
num_children = 25
# Children actors will die about half the time.
death_probability = 0.5
children = [Child.remote(death_probability) for _ in range(num_children)]
while len(cluster.list_all_nodes()) > 1:
for j in range(2):
# Submit some tasks on the actors. About half of the actors will
# fail.
children_out = [child.ping.remote() for child in children]
# Wait a while for all the tasks to complete. This should trigger
# reconstruction for any actor creation tasks that were forwarded
# to nodes that then failed.
ready, _ = ray.wait(
children_out, num_returns=len(children_out), timeout=5 * 60.0)
assert len(ready) == len(children_out)
# Replace any actors that died.
for i, out in enumerate(children_out):
try:
ray.get(out)
except ray.exceptions.RayActorError:
children[i] = Child.remote(death_probability)
# Remove a node. Any actor creation tasks that were forwarded to this
# node must be resubmitted.
cluster.remove_node(get_other_nodes(cluster, True)[-1])
def test_driver_lives_sequential(ray_start_regular):
ray.worker._global_node.kill_raylet()
ray.worker._global_node.kill_plasma_store()
ray.worker._global_node.kill_log_monitor()
ray.worker._global_node.kill_monitor()
ray.worker._global_node.kill_gcs_server()
# If the driver can reach the tearDown method, then it is still alive.
def test_driver_lives_parallel(ray_start_regular):
all_processes = ray.worker._global_node.all_processes
process_infos = (all_processes[ray_constants.PROCESS_TYPE_PLASMA_STORE] +
all_processes[ray_constants.PROCESS_TYPE_GCS_SERVER] +
all_processes[ray_constants.PROCESS_TYPE_RAYLET] +
all_processes[ray_constants.PROCESS_TYPE_LOG_MONITOR] +
all_processes[ray_constants.PROCESS_TYPE_MONITOR])
assert len(process_infos) == 5
# Kill all the components in parallel.
for process_info in process_infos:
process_info.process.terminate()
time.sleep(0.1)
for process_info in process_infos:
process_info.process.kill()
for process_info in process_infos:
process_info.process.wait()
# If the driver can reach the tearDown method, then it is still alive.
if __name__ == "__main__":
import pytest
sys.exit(pytest.main(["-v", __file__]))
| {
"content_hash": "2606b4fe56130adf9f6f78095ee18376",
"timestamp": "",
"source": "github",
"line_count": 161,
"max_line_length": 79,
"avg_line_length": 33.7888198757764,
"alnum_prop": 0.616360294117647,
"repo_name": "richardliaw/ray",
"id": "3dc65be557c14ed7fba2e533c493d9151475d12e",
"size": "5440",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "python/ray/tests/test_multinode_failures_2.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "C",
"bytes": "62178"
},
{
"name": "C++",
"bytes": "4258483"
},
{
"name": "CSS",
"bytes": "8025"
},
{
"name": "Dockerfile",
"bytes": "6292"
},
{
"name": "HTML",
"bytes": "30414"
},
{
"name": "Java",
"bytes": "1263157"
},
{
"name": "JavaScript",
"bytes": "444"
},
{
"name": "Jupyter Notebook",
"bytes": "1615"
},
{
"name": "Makefile",
"bytes": "234"
},
{
"name": "Python",
"bytes": "7515224"
},
{
"name": "Shell",
"bytes": "117425"
},
{
"name": "Starlark",
"bytes": "200955"
},
{
"name": "TypeScript",
"bytes": "149068"
}
],
"symlink_target": ""
} |
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('activities', '0002_auto_20160527_0932'),
]
operations = [
migrations.RemoveField(
model_name='projectactivity',
name='allowed_submissions',
),
]
| {
"content_hash": "7dfaa86ea69ba202a1a21ed7e3a6affe",
"timestamp": "",
"source": "github",
"line_count": 17,
"max_line_length": 50,
"avg_line_length": 20.294117647058822,
"alnum_prop": 0.6115942028985507,
"repo_name": "zurfyx/simple",
"id": "a862679a4ec6f71e781fe440a0c8c3af61634b21",
"size": "417",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "simple/projects/activities/migrations/0003_remove_projectactivity_allowed_submissions.py",
"mode": "33261",
"license": "mit",
"language": [
{
"name": "CSS",
"bytes": "11344"
},
{
"name": "HTML",
"bytes": "95034"
},
{
"name": "JavaScript",
"bytes": "2521"
},
{
"name": "Python",
"bytes": "137848"
}
],
"symlink_target": ""
} |
"""
Created on Tue May 17 01:01:31 2016
@author: Ghareeb
"""
from PythonStarterApp import app
import os
if 'VCAP_APP_PORT' in os.environ:
appPort = os.environ['VCAP_APP_PORT']
else:
appPort = 5000
if 'VCAP_APP_HOST' in os.environ:
appHost = os.environ['VCAP_APP_HOST']
else:
appHost = '0.0.0.0'
if __name__ == '__main__':
app.run(host=appHost,port=appPort, debug=False, threaded=True) | {
"content_hash": "f566f43886aa68120cc3974d6b1a866c",
"timestamp": "",
"source": "github",
"line_count": 21,
"max_line_length": 66,
"avg_line_length": 19.666666666666668,
"alnum_prop": 0.6513317191283293,
"repo_name": "YDnepr/practicalcourse",
"id": "f7e1754dee410196b1a84683110ad00db87d8e77",
"size": "437",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "welcome.py",
"mode": "33188",
"license": "apache-2.0",
"language": [
{
"name": "CSS",
"bytes": "1082"
},
{
"name": "HTML",
"bytes": "5064"
},
{
"name": "Python",
"bytes": "18039"
}
],
"symlink_target": ""
} |
import operator
import numpy as np
def l1_min_c(X, y, loss='l2', fit_intercept=True, intercept_scaling=1.0):
"""
Return the maximum value for C that yields a model with coefficients
and intercept set to zero for l1 penalized classifiers,
such as LinearSVC with penalty='l1' and linear_model.LogisticRegression
with penalty='l1'.
This value is valid if class_weight parameter in fit() is not set.
Parameters
----------
X : array-like or sparse matrix, shape = [n_samples, n_features]
Training vector, where n_samples in the number of samples and
n_features is the number of features.
y : array, shape = [n_samples]
Target vector relative to X
loss : {'l2', 'log'}, default to 'l2'
Specifies the loss function.
With 'l2' it is the l2 loss (a.k.a. squared hinge loss).
With 'log' it is the loss of logistic regression models.
fit_intercept : bool, default: True
Specifies if the intercept should be fitted by the model.
It must match the fit() method paramenter.
intercept_scaling : float, default: 1
when fit_intercept is True, instance vector x becomes
[x, intercept_scaling],
i.e. a "synthetic" feature with constant value equals to
intercept_scaling is appended to the instance vector.
It must match the fit() method parameter.
Returns
-------
l1_min_c: float
minimum value for C
"""
import scipy.sparse as sp
if loss not in ('l2', 'log'):
raise ValueError('loss type not in ("l2", "log")')
y = np.asanyarray(y)
if sp.issparse(X):
X = sp.csc_matrix(X)
hstack = sp.hstack
dot = operator.mul
else:
X = np.asanyarray(X)
hstack = np.hstack
dot = np.dot
if fit_intercept:
bias = intercept_scaling * np.ones((np.size(y), 1))
X = hstack((X, bias))
classes = np.unique(y)
n_classes = np.size(classes)
if n_classes <= 2:
c = classes[0]
y = y.reshape((1, -1))
_y = np.empty(y.shape)
_y[y == c] = 1
_y[y != c] = -1
else:
_y = np.empty((n_classes, np.size(y)))
for i, c in enumerate(classes):
_y[i, y == c] = 1
_y[i, y != c] = -1
den = np.max(np.abs(dot(_y, X)))
if den == 0.0:
raise ValueError('Ill-posed l1_min_c calculation')
if loss == 'l2':
return 0.5 / den
else: # loss == 'log':
return 2.0 / den
| {
"content_hash": "6b236713c68e63838f58f95a0372545f",
"timestamp": "",
"source": "github",
"line_count": 84,
"max_line_length": 75,
"avg_line_length": 30,
"alnum_prop": 0.5781746031746032,
"repo_name": "ominux/scikit-learn",
"id": "b5fb30ef03fe3c0bed97adb1934dc01f9d136bc3",
"size": "2520",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "sklearn/svm/bounds.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "C",
"bytes": "455969"
},
{
"name": "C++",
"bytes": "240380"
},
{
"name": "Makefile",
"bytes": "1411"
},
{
"name": "Python",
"bytes": "2064853"
},
{
"name": "Shell",
"bytes": "486"
}
],
"symlink_target": ""
} |
import re
import pickle
import copy
import traceback
from collections import OrderedDict
from OpenGL.GL import *
from OpenGL.GL.shaders import *
from OpenGL.GL.shaders import glDeleteShader
import numpy as np
from PyEngine3D.Common import logger
from PyEngine3D.Utilities import Attributes, Logger
from PyEngine3D.App import CoreManager
from PyEngine3D.OpenGLContext import OpenGLContext, CreateUniformDataFromString
from .UniformBuffer import CreateUniformBuffer, UniformTextureBase
class Material:
def __init__(self, material_name, material_datas={}):
self.valid = False
logger.info("Load %s material." % material_name)
# for save
self.material_datas = material_datas
shader_codes = material_datas.get('shader_codes')
binary_format = material_datas.get('binary_format')
binary_data = material_datas.get('binary_data')
uniforms = material_datas.get('uniforms', [])
uniform_datas = material_datas.get('uniform_datas', {})
self.material_component_names = [x[1] for x in material_datas.get('material_components', [])]
self.macros = material_datas.get('macros', OrderedDict())
self.is_translucent = True if 0 < self.macros.get('TRANSPARENT_MATERIAL', 0) else False
self.name = material_name
self.shader_name = material_datas.get('shader_name', '')
self.program = -1
self.uniform_buffers = dict() # OrderedDict() # Declaration order is important.
self.Attributes = Attributes()
if binary_format is not None and binary_data is not None:
self.compile_from_binary(binary_format, binary_data)
self.valid = self.check_validate() and self.check_linked()
if not self.valid:
logger.error("%s material has been failed to compile from binary" % self.name)
self.compile_message = ""
if not self.valid:
self.compile_from_source(shader_codes)
self.valid = self.check_validate() and self.check_linked()
if not self.valid:
logger.error("%s material has been failed to compile from source" % self.name)
if self.valid:
self.create_uniform_buffers(uniforms, uniform_datas)
def get_save_data(self):
uniform_datas = {}
for uniform_name in self.uniform_buffers:
default_value = self.uniform_buffers[uniform_name].get_default_value()
if default_value is not None:
if hasattr(default_value, 'name'):
uniform_datas[uniform_name] = default_value.name
else:
uniform_datas[uniform_name] = default_value
self.material_datas['uniform_datas'] = uniform_datas
return self.material_datas
def get_attribute(self):
self.Attributes.set_attribute('name', self.name)
self.Attributes.set_attribute('shader_name', self.shader_name)
for key in self.macros:
self.Attributes.set_attribute(key, self.macros[key])
for uniform_buffer in self.uniform_buffers.values():
self.Attributes.set_attribute(uniform_buffer.name, uniform_buffer.get_default_value())
return self.Attributes
def set_attribute(self, attribute_name, attribute_value, parent_info, attribute_index):
if attribute_name in self.macros and self.macros[attribute_name] != attribute_value:
new_macros = copy.deepcopy(self.macros)
new_macros[attribute_name] = attribute_value
# if macro was changed then create a new material.
CoreManager.instance().resource_manager.get_material(self.shader_name, new_macros)
elif attribute_name in self.uniform_buffers:
uniform_buffer = self.uniform_buffers[attribute_name]
default_value = CreateUniformDataFromString(uniform_buffer.uniform_type, attribute_value)
uniform_buffer.set_default_value(default_value)
def delete(self):
OpenGLContext.use_program(0)
glDeleteProgram(self.program)
logger.info("Deleted %s material." % self.name)
def use_program(self):
OpenGLContext.use_program(self.program)
def save_to_binary(self):
size = GLint()
glGetProgramiv(self.program, GL_PROGRAM_BINARY_LENGTH, size)
# very important - check data dtype np.ubyte
binary_data = np.zeros(size.value, dtype=np.ubyte)
binary_size = GLint()
binary_format = GLenum()
glGetProgramBinary(self.program, size.value, binary_size, binary_format, binary_data)
binary_data = pickle.dumps(binary_data)
return binary_format, binary_data
def compile_from_binary(self, binary_format, binary_data):
binary_data = pickle.loads(binary_data)
self.program = glCreateProgram()
glProgramParameteri(self.program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE)
glProgramBinary(self.program, binary_format.value, binary_data, len(binary_data))
def compile_from_source(self, shader_codes: dict):
shaders = []
for shader_type in shader_codes:
shader = self.compile(shader_type, shader_codes[shader_type])
if shader is not None:
logger.info("Compile %s %s." % (self.name, shader_type))
shaders.append(shader)
self.program = glCreateProgram()
# glProgramParameteri(self.program, GL_PROGRAM_SEPARABLE, GL_TRUE)
glProgramParameteri(self.program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE)
for shader in shaders:
glAttachShader(self.program, shader)
glLinkProgram(self.program)
for shader in shaders:
glDetachShader(self.program, shader)
glDeleteShader(shader)
def create_uniform_buffers(self, uniforms, default_uniform_datas={}):
# create uniform buffers from source code
active_texture_index = 0
for uniform_type, uniform_name in uniforms:
# self.uniform_datas
default_data = CreateUniformDataFromString(uniform_type, default_uniform_datas.get(uniform_name))
uniform_buffer = CreateUniformBuffer(self.program, uniform_type, uniform_name, default_data=default_data)
if uniform_buffer is not None:
# Important : set texture binding index
if issubclass(uniform_buffer.__class__, UniformTextureBase):
uniform_buffer.set_texture_index(active_texture_index)
active_texture_index += 1
self.uniform_buffers[uniform_name] = uniform_buffer
else:
logger.warn("%s material has no %s uniform variable. It may have been optimized by the compiler..)" % (self.name, uniform_name))
return True
def compile(self, shaderType, shader_code):
"""
:param shaderType: GL_VERTEX_SHADER, GL_FRAGMENT_SHADER
:param shader_code: string
"""
if shader_code == "" or shader_code is None:
return None
try:
# Compile shaders
shader = glCreateShader(shaderType)
glShaderSource(shader, shader_code)
glCompileShader(shader)
compile_status = glGetShaderiv(shader, GL_COMPILE_STATUS)
if compile_status != 1:
infoLogs = glGetShaderInfoLog(shader)
if infoLogs:
if type(infoLogs) == bytes:
infoLogs = infoLogs.decode("utf-8")
infoLogs = ("GL_COMPILE_STATUS : %d\n" % compile_status) + infoLogs
shader_code_lines = shader_code.split('\n')
infoLogs = infoLogs.split('\n')
for i, infoLog in enumerate(infoLogs):
error_line = re.match('\d\((\d+)\) : error', infoLog)
if error_line is not None:
# show prev 3 lines
error_line = int(error_line.groups()[0]) - 1
for num in range(max(0, error_line - 3), error_line):
infoLogs[i] += "\n\t %s" % (shader_code_lines[num])
# show last line
infoLogs[i] += "\n\t--> %s" % (shader_code_lines[error_line])
infoLogs = "\n".join(infoLogs)
self.compile_message = "\n".join([self.compile_message, infoLogs])
logger.error("%s %s shader compile error.\n%s" % (self.name, shaderType.name, infoLogs))
else:
# complete
logger.log(Logger.MINOR_INFO, "Complete %s %s compile." % (self.name, shaderType.name))
return shader
except BaseException:
logger.error(traceback.format_exc())
return None
def check_validate(self):
if self.program >= 0:
glValidateProgram(self.program)
validation = glGetProgramiv(self.program, GL_VALIDATE_STATUS)
if validation == GL_TRUE:
return True
else:
logger.warn("Validation failure (%s): %s" % (validation, glGetProgramInfoLog(self.program)))
else:
logger.warn("Validation failure : %s" % self.name)
# always return True
return True
def check_linked(self):
if self.program >= 0:
link_status = glGetProgramiv(self.program, GL_LINK_STATUS)
if link_status == GL_TRUE:
return True
else:
logger.error("Link failure (%s): %s" % (link_status, glGetProgramInfoLog(self.program)))
else:
logger.error("Link failure : %s" % self.name)
return False
| {
"content_hash": "dde018f7e7289676a1bc10a16d1a7a96",
"timestamp": "",
"source": "github",
"line_count": 228,
"max_line_length": 144,
"avg_line_length": 42.93421052631579,
"alnum_prop": 0.6086423536622739,
"repo_name": "ubuntunux/GuineaPig",
"id": "4e15d252c897513e7c98d17a7185cc3c96b40d97",
"size": "9789",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "PyEngine3D/OpenGLContext/Material.py",
"mode": "33188",
"license": "bsd-2-clause",
"language": [
{
"name": "GLSL",
"bytes": "6355"
},
{
"name": "Python",
"bytes": "216821"
}
],
"symlink_target": ""
} |
horovod = "/home/wozniak/proj/horovod"
execfile(horovod+"/examples/keras_mnist.py")
| {
"content_hash": "1de5af91e12d0b259be772e5387987b8",
"timestamp": "",
"source": "github",
"line_count": 2,
"max_line_length": 44,
"avg_line_length": 42,
"alnum_prop": 0.7619047619047619,
"repo_name": "ECP-CANDLE/Supervisor",
"id": "cddb5c20dadf4fba259eecb09de4a97ccb480f58",
"size": "84",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "scratch/horovod/horovod-1.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Awk",
"bytes": "592"
},
{
"name": "C",
"bytes": "27472"
},
{
"name": "C++",
"bytes": "7545"
},
{
"name": "Jupyter Notebook",
"bytes": "246450"
},
{
"name": "M4",
"bytes": "3815"
},
{
"name": "Makefile",
"bytes": "8870"
},
{
"name": "Python",
"bytes": "362007"
},
{
"name": "R",
"bytes": "155474"
},
{
"name": "SWIG",
"bytes": "788"
},
{
"name": "Shell",
"bytes": "310198"
},
{
"name": "Swift",
"bytes": "124184"
},
{
"name": "TSQL",
"bytes": "2772"
},
{
"name": "Tcl",
"bytes": "2223"
}
],
"symlink_target": ""
} |
import tkinter
import math
import logging
import os
import logika_igre
import clovek
import racunalnik
import alfabeta
###########################################################################
# KONSTANTE #
###########################################################################
STRANICA_SESTKOTNIKA = 20
# visina trikotnikov v sestkotniku
VISINA_TRIKOTNIKA = 3 ** (0.5) * (0.5) * STRANICA_SESTKOTNIKA
PRAZNO = logika_igre.PRAZNO
NI_KONEC = logika_igre.NI_KONEC
NEODLOCENO = logika_igre.NEODLOCENO
# možne barvne kombinacije igralnih polj
# v primeru dodajanja novih je potrebno dopolniti še funkcijo izpis_igralca
# ter izbire v menuju barva_menu
kombinacije_barv = [('red', 'blue'), ('red', 'green'), ('blue', 'green')]
# uporabljeno v Textwidgetu
END = 'end'
###########################################################################
# GUI #
###########################################################################
class Gui():
def __init__(self, master):
# PLOSCA
self.plosca = tkinter.Canvas(master)
self.plosca.grid(row=1, column=0)
# 'naročimo' se na levi klik miške
self.plosca.bind("<Button-1>", self.plosca_klik)
# POLJE ZA SPOROCILA
self.napis = tkinter.StringVar(master, value='')
tkinter.Label(master, textvariable=self.napis).grid(row=0, column=0)
# SHRANJEVANJE PODATKOV O POLJIH
# Ključi so id, vrednosti koordinate.
self.id_koord = {}
# Ključi so koordinate (i, j), vrednosti id-ji
self.koord_id = {}
# ZAČNEMO NOVO IGRO
self.igra = None
self.igralec_1 = None # Objekt, ki igra IGRALEC_1 (nastavimo ob začetku igre)
self.igralec_2 = None # Objekt, ki igra IGRALEC_2 (nastavimo ob začetku igre)
# najprej nastavimo nastavitve za igro
# igro zacnemo v barvni kombinaciji rdeca-modra (izbira 0)
self.barva = tkinter.IntVar(value=0)
# na polju velikosti 15x15
self.velikost_matrike = tkinter.IntVar(value=15)
# v nacinu clovek-racunalnik (izbira 1)
self.nacin_igre = tkinter.IntVar(value=1)
# zacnemo igro
self.zacni_igro()
# ZAPIRANJE OKNA
# Če uporabnik zapre okno naj se poklice self.zapri_okno
master.protocol("WM_DELETE_WINDOW", lambda: self.zapri_okno(master))
# GLAVNI MENU
glavni_menu = tkinter.Menu(master)
master.config(menu=glavni_menu)
# PODMENUJI
igra_menu = tkinter.Menu(glavni_menu, tearoff=0)
glavni_menu.add_cascade(label="Igra", menu=igra_menu)
nacini_menu = tkinter.Menu(glavni_menu, tearoff=0)
glavni_menu.add_cascade(label="Nastavitve igre", menu=nacini_menu)
velikost_menu = tkinter.Menu(glavni_menu, tearoff=0)
glavni_menu.add_cascade(label="Velikost polja", menu=velikost_menu)
barva_menu = tkinter.Menu(glavni_menu, tearoff=0)
glavni_menu.add_cascade(label="Barva", menu=barva_menu)
pomoc_menu = tkinter.Menu(glavni_menu, tearoff=0)
glavni_menu.add_cascade(label="Pomoč", menu=pomoc_menu)
# IZBIRE V PODMENUJIH
igra_menu.add_command(label="Nova igra", command=lambda: self.zacni_igro())
nacini_menu.add_radiobutton(label="Človek - Človek", variable=self.nacin_igre, value=0, command=lambda: self.zacni_igro())
nacini_menu.add_radiobutton(label="Človek - Računalnik", variable=self.nacin_igre, value=1, command=lambda: self.zacni_igro())
nacini_menu.add_radiobutton(label="Računalnik - Človek", variable=self.nacin_igre, value=2, command=lambda: self.zacni_igro())
nacini_menu.add_radiobutton(label="Računalnik - Računalnik", variable=self.nacin_igre, value=3, command=lambda: self.zacni_igro())
velikost_menu.add_radiobutton(label="10x10", variable=self.velikost_matrike, value=10, command=lambda: self.zacni_igro())
velikost_menu.add_radiobutton(label="15x15", variable=self.velikost_matrike, value=15, command=lambda: self.zacni_igro())
velikost_menu.add_radiobutton(label="20x20", variable=self.velikost_matrike, value=20, command=lambda: self.zacni_igro())
barva_menu.add_radiobutton(label="rdeča-modra", variable=self.barva, value=0, command=lambda: self.zacni_igro())
barva_menu.add_radiobutton(label="rdeča-zelena", variable=self.barva, value=1, command=lambda: self.zacni_igro())
barva_menu.add_radiobutton(label="modra-zelena", variable=self.barva, value=2, command=lambda: self.zacni_igro())
pomoc_menu.add_command(label="Navodila", command=lambda: self.odpri_navodila())
##################################
# IGRA #
##################################
def zacni_igro(self):
'''Nastavi stanje igre na zacetek igre'''
# Ustavimo vsa vlakna, ki trenutno razmišljajo in pocistimo plosco
self.prekini_igralce()
self.plosca.delete('all')
# nastavimo barvo
self.nastavi_barvo_igralnih_polj()
# nastavimo velikost
self.nastavi_velikost_igralnega_polja()
# shranimo igralce
self.nastavi_nacin_igre()
# ustvarimo novo igro
self.igra = logika_igre.Igra()
# nastavimo stvari vidne uporabniku
self.napis.set('Na potezi je {0}.'.format(self.izpis_igralca(logika_igre.drugi)))
self.napolni_igralno_polje()
# prvi na potezi je igralec 2, saj je prvo polje že pobarvano
# z barvo igralca 1
self.igra.na_potezi = logika_igre.drugi
self.igralec_2.igraj()
def prekini_igralce(self):
"""Sporoči igralcem, da morajo nehati razmišljati."""
if self.igralec_1: self.igralec_1.prekini()
if self.igralec_2: self.igralec_2.prekini()
def povleci_potezo(self, i, j):
'''logiki igre naroci naj povlece potezo,
potem pa se ona ukvarja z veljavnostjo'''
barva = self.igra.na_potezi
# izvedemo potezo v logiki igre
poteza = self.igra.izvedi_potezo(i, j)
# poteza ni bila veljavna, ne naredimo nič
if poteza == None:
pass
# poteza je bila veljavna
else:
# pobarvamo polje
id = self.koord_id[(i, j)]
self.plosca.itemconfig(id, fill=barva)
# nadaljujemo igro
(zmagovalec, zmagovalna_polja) = poteza
if zmagovalec == NI_KONEC:
# poklicemo naslednjega igralca
if self.igra.na_potezi == logika_igre.prvi:
self.igralec_1.igraj()
self.napis.set('Na potezi je {0}.'.format(self.izpis_igralca(logika_igre.prvi)))
else:
self.igralec_2.igraj()
self.napis.set('Na potezi je {0}.'.format(self.izpis_igralca(logika_igre.drugi)))
else:
self.konec_igre(zmagovalec, zmagovalna_polja)
self.prekini_igralce()
self.igra.na_potezi = None
###########################################
# NASTAVITVE IGRE #
###########################################
def nastavi_velikost_igralnega_polja(self):
'''nastavi velikost igralnega polja'''
velikost_matrike = self.velikost_matrike.get()
# nastavimo velikost v logiki_igre
logika_igre.velikost_matrike = velikost_matrike
# izracunamo sirino in visino
sirina = VISINA_TRIKOTNIKA * 2 * velikost_matrike + STRANICA_SESTKOTNIKA + 1
visina = 1.5 * STRANICA_SESTKOTNIKA * velikost_matrike + 0.5 * STRANICA_SESTKOTNIKA + 1
self.plosca.config(width=sirina, height=visina)
def nastavi_barvo_igralnih_polj(self):
'''nastavi barvo igralnih polj'''
kombinacija = self.barva.get()
logika_igre.prvi = kombinacije_barv[kombinacija][0]
logika_igre.drugi = kombinacije_barv[kombinacija][1]
def nastavi_nacin_igre(self):
'''nastavi igralce'''
nacini_igre = [(clovek.Clovek(self), clovek.Clovek(self)),
(clovek.Clovek(self), racunalnik.Racunalnik(self, alfabeta.Alfabeta(alfabeta.globina))),
(racunalnik.Racunalnik(self, alfabeta.Alfabeta(alfabeta.globina)), clovek.Clovek(self)),
(racunalnik.Racunalnik(self, alfabeta.Alfabeta(alfabeta.globina)), racunalnik.Racunalnik(self, alfabeta.Alfabeta(alfabeta.globina)))]
nacin = self.nacin_igre.get()
self.igralec_1 = nacini_igre[nacin][0]
self.igralec_2 = nacini_igre[nacin][1]
###########################################
# OSTALE FUNKCIJE #
###########################################
def plosca_klik(self, event):
'''določi koordinate klika in pokliče ustreznega igralca'''
m = event.x
n = event.y
id = self.plosca.find_closest(m, n)[0]
(i, j) = self.id_koord[id]
if self.igra.na_potezi == logika_igre.prvi:
self.igralec_1.klik(i, j)
elif self.igra.na_potezi == logika_igre.drugi:
self.igralec_2.klik(i, j)
else:
pass
def narisi_sestkotnik(self, x, y):
'''nariše šestkotnik in vrne njegov id'''
a = STRANICA_SESTKOTNIKA
v = VISINA_TRIKOTNIKA
t = [x, y + a * 0.5,
x + v, y,
x + 2 * v,y + (0.5) * a,
x + 2 * v, y + 1.5 * a,
x + v, y + 2 * a,
x, y + 1.5 * a]
id = self.plosca.create_polygon(*t, fill=PRAZNO, outline='black')
return id
def napolni_igralno_polje(self):
'''nariše igralno polje sestavljeno iz šestkotnikov'''
a = STRANICA_SESTKOTNIKA
v = VISINA_TRIKOTNIKA
velikost_matrike = logika_igre.velikost_matrike
for i in range(velikost_matrike): # vrstica
# preverimo sodost/lihost in tako določimo zamik prvega šestkotnika
if i % 2 == 0: # lihe vrstice (ker začnemo šteti z 0)
zacetni_x = 2
for j in range(velikost_matrike): # stolpec
x = zacetni_x + j * 2 * v
y = i * 1.5 * a + 2
id = self.narisi_sestkotnik(x, y)
self.id_koord[id] = (i, j)
self.koord_id[(i,j)] = id
else: # sode vrstice
zacetni_x = v + 2
for j in range(velikost_matrike): # stolpec
x = zacetni_x + j * 2 * v
y = i * 1.5 * a + 2
id = self.narisi_sestkotnik(x, y)
self.id_koord[id] = (i, j)
self.koord_id[(i, j)] = id
# pobarvamo prvo polje
self.pobarvaj_prvo_polje()
def pobarvaj_prvo_polje(self):
'''pobarva prvo polje z barvo igralca 1 in spremembo zabeleži v logiko igre'''
i = logika_igre.velikost_matrike // 2
j = i
barva = logika_igre.prvi
sredina = self.koord_id[(i,j)]
self.plosca.itemconfig(sredina, fill=barva)
self.igra.zabelezi_spremembo_barve(i, j, barva)
self.igra.zadnja_poteza = (i, j)
self.igra.stevilo_pobarvanih_polj += 1
def izpis_igralca(self, igralec):
'''pravilno sklanja ime igralca, za izpis uporabniku'''
if igralec == 'red':
return 'rdeči'
elif igralec == 'blue':
return 'modri'
elif igralec == 'green':
return 'zeleni'
def konec_igre(self, zmagovalec, zmagovalna_polja):
'''uvede ustrezne spremembe v oknu'''
# igre je konec, imamo zmagovalca
if zmagovalec in [logika_igre.prvi, logika_igre.drugi]:
self.napis.set('Zmagal je {0}.'.format(self.izpis_igralca(zmagovalec)))
for (i, j) in zmagovalna_polja:
# odebelimo zmagovalna polja
id = self.koord_id[(i, j)]
self.plosca.itemconfig(id, width=3)
# igre je konec, rezultat je izenacen
else:
self.napis.set('Igra je neodločena.')
def zapri_okno(self, master):
'''Ta metoda se pokliče, ko uporabnik zapre aplikacijo.'''
self.prekini_igralce()
# Dejansko zapremo okno.
master.destroy()
###########################################
# POMOČ UPORABNIKU #
###########################################
def odpri_navodila(self):
'''odpre okno z navodili za igro'''
pomoc_igra = tkinter.Toplevel()
pomoc_igra.title("Pravila in navodila")
pomoc_igra.resizable(width=False, height=False)
navodila1 = tkinter.Text(pomoc_igra, width=65, height=3)
navodila1.grid(row=0, column=0)
navodila1.insert(END, 'Pozdravljeni! \n \n')
navodila1.insert(END, 'V igri SIX morate za zmago tvoriti enega od naslednjih vzorcev:')
navodila1.config(state='disabled')
vzorci = tkinter.PhotoImage(file=os.path.join('navodila','vzorci.gif'))
slika1 = tkinter.Label(pomoc_igra, image = vzorci)
slika1.image = vzorci
slika1.grid(row=1, column=0)
navodila2 = tkinter.Text(pomoc_igra, width=65, height=6)
navodila2.grid(row=2, column=0)
navodila2.insert(END, '')
navodila2.insert(END, 'Polje, ki ga želite izbrati, mora imeti vsaj enega že pobarvanega'
'soseda, sicer poteza ni veljavna. \n')
navodila2.insert(END, 'Nad igralnim poljem se nahaja vrstica stanja, kjer vidite \n' 'trenutno stanje igre. \n')
navodila2.insert(END, 'V primeru zmage se v vrstici stanja izpiše zmagovalec, \n' 'zmagovalni vzorec pa se poudari.')
navodila2.config(state='disabled')
if __name__.endswith('__main__'):
root = tkinter.Tk()
root.title("SIX")
root.resizable(width=False, height=False)
#logging.basicConfig(level=logging.DEBUG)
aplikacija = Gui(root)
root.iconbitmap(os.path.join('ikona','matica.ico'))
root.mainloop()
| {
"content_hash": "fefceb4b254a1302a2a02e60648815f1",
"timestamp": "",
"source": "github",
"line_count": 350,
"max_line_length": 149,
"avg_line_length": 40.894285714285715,
"alnum_prop": 0.5639628309928038,
"repo_name": "PircK/six",
"id": "ad14d249e9a39f9995c800b6f357caf7b5cd4e52",
"size": "14357",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "sliks.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "37324"
}
],
"symlink_target": ""
} |
from setuptools import setup
setup(
name = "bibulous",
py_modules = ['bibulous', 'bibulous_test', 'bibulous_authorextract'],
version = "1.3.2",
description = "BibTeX replacement and enhancement",
author = "Nathan Hagen",
author_email = "[email protected]",
url = "https://github.com/nzhagen/bibulous",
download_url = "https://github.com/nzhagen/bibulous/blob/master/bibulous.py",
license = "MIT",
keywords = ["bibtex", "bibliography", "parser", "tex", "latex"],
classifiers = [
"Programming Language :: Python :: 2.7",
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Text Processing :: Markup :: LaTeX",
"Topic :: Text Processing",
],
long_description = """\
A drop-in replacement for BibTeX based on string templates.
-----------------------------------------------------------
Bibulous provides a flexible way of accomplishing the same tasks as BibTeX, and going
beyond it in capability. Some of its advantages include:
- An integrated BibTeX database file (.bib file) parser.
- Fully internationalized: Bibulous can use bibliography databases and bibliography style
files written in any language.
- Simple and powerful customization: style templates are an ideal way of visualizing and
manipulating bibliography styles. There is no need to learn BibTeX's arcane stack-based
language in order to build or customize a bibliography style.
- Multilingual capability: templates are largely language agnostic, so that multilingual
bibliographies can be achieved almost effortlessly.
- Users can build glossaries, lists of symbols, and lists of acronyms using the same
infrastructure as used for bibliographies.
- Sorting of citations is fully localized and has no difficulty in dealing with strings
that contain Unicode, LaTeX-markup characters for non-English languages, or even
mathematics markup.
This version requires Python 2.7 or later.
"""
)
| {
"content_hash": "63f7fcd07f29bfd31144739e49482e08",
"timestamp": "",
"source": "github",
"line_count": 45,
"max_line_length": 91,
"avg_line_length": 46.355555555555554,
"alnum_prop": 0.6922339405560882,
"repo_name": "ghareth/bibulous",
"id": "f5984ef2d132faa20bb6f6e9b5d0541cef6c10ca",
"size": "2141",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "setup.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "257058"
},
{
"name": "TeX",
"bytes": "8034667"
}
],
"symlink_target": ""
} |
import pytest
from bayes_opt.bayesian_optimization import Queue
def test_add():
queue = Queue()
assert len(queue) == 0
assert queue.empty
queue.add(1)
assert len(queue) == 1
queue.add(1)
assert len(queue) == 2
queue.add(2)
assert len(queue) == 3
def test_queue():
queue = Queue()
with pytest.raises(StopIteration):
next(queue)
queue.add(1)
queue.add(2)
queue.add(3)
assert len(queue) == 3
assert not queue.empty
assert next(queue) == 1
assert len(queue) == 2
assert next(queue) == 2
assert next(queue) == 3
assert len(queue) == 0
if __name__ == '__main__':
r"""
CommandLine:
python tests/test_observer.py
"""
pytest.main([__file__])
| {
"content_hash": "750c3eb65c259be25a15a1fcfd98e50f",
"timestamp": "",
"source": "github",
"line_count": 49,
"max_line_length": 49,
"avg_line_length": 15.63265306122449,
"alnum_prop": 0.5718015665796344,
"repo_name": "fmfn/BayesianOptimization",
"id": "0aba7b747bb261b395869a6b5e92640d28739f29",
"size": "766",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "tests/test_queue.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "84494"
}
],
"symlink_target": ""
} |
from django import forms
from models import *
class ChoiceField(forms.ChoiceField):
def __init__(self, choices=(), empty_label=None, required=True, widget=None, label=None,
initial=None, help_text=None, *args, **kwargs):
# prepend an empty label if it exists (and field is not required!)
if empty_label is not None:
choices = tuple([(u'', empty_label)] + list(choices))
super(ChoiceField, self).__init__(choices=choices, required=required, widget=widget, label=label,
initial=initial, help_text=help_text, *args, **kwargs)
class GraphSafesForm(forms.Form):
manufacturers = ChoiceField( choices=((opt['name'], opt['name']) for opt in
Manufacturer.objects.filter(safeprofile__isnull=False, name__isnull=False).values('name').distinct()), required=True, empty_label="Select a manufacturer" )
stores = ChoiceField( choices=((opt['name'], opt['name']) for opt in
Store.objects.filter(safeprofile__isnull=False, name__isnull=False).values('name').distinct()), required=True, empty_label="Select a store" )
categories = ChoiceField( choices=((opt['name'], opt['name']) for opt in
SafeCategory.objects.filter(name__isnull=False).values('name').distinct()), required=True, empty_label="Select a category" )
volumes = ChoiceField( choices=((opt['volume'], opt['volume']) for opt in
SafeProfile.objects.filter(volume__isnull=False).values('volume').distinct()), required=True, empty_label="Select a volume" )
weights = ChoiceField( choices=((opt['weight'], opt['weight']) for opt in
SafeProfile.objects.filter(weight__isnull=False).values('weight').distinct()), required=True, empty_label="Select a weight" )
lock_ratings = ChoiceField( choices=((opt['rating'], opt['rating']) for opt in
LockRating.objects.filter(rating__isnull=False).values('rating').distinct()), required=True, empty_label="Select a lock rating" )
bolt_diameters = ChoiceField( choices=((opt['bolt_diameter'], opt['bolt_diameter']) for opt in
SafeProfile.objects.filter(bolt_diameter__isnull=False).values('bolt_diameter').distinct()), required=True, empty_label="Select a bolt diameter" )
door_thicknesses = ChoiceField( choices=((opt['door_thickness'], opt['door_thickness']) for opt in
SafeProfile.objects.filter(door_thickness__isnull=False).values('door_thickness').distinct()), required=True, empty_label="Select a door thickness" )
safe_ratings = forms.MultipleChoiceField( choices=((opt['rating'], opt['rating']) for opt in
SafeRating.objects.filter(rating__isnull=False).filter(safeprofile__isnull=False).values('rating').distinct()))
features = forms.MultipleChoiceField( choices=((opt['name'], opt['name']) for opt in
SafeFeature.objects.filter(name__isnull=False).values('name').distinct()), required=True)
class GraphSafeComponentForm(forms.Form):
manufacturers = ChoiceField( choices=((opt['name'], opt['name']) for opt in
Manufacturer.objects.filter(safecomponentprofile__isnull=False, name__isnull=False).values('name').distinct()), required=True, empty_label="Select a manufacturer" )
stores = ChoiceField( choices=((opt['name'], opt['name']) for opt in
Store.objects.filter(safecomponentprofile__isnull=False, name__isnull=False).values('name').distinct()), required=True, empty_label="Select a store" )
categories = ChoiceField( choices=((opt['name'], opt['name']) for opt in
SafeCategory.objects.filter(name__isnull=False).values('name').distinct()), required=True, empty_label="Select a category" )
| {
"content_hash": "fbc6f6c5ecb6604595761dabe1259de3",
"timestamp": "",
"source": "github",
"line_count": 65,
"max_line_length": 184,
"avg_line_length": 58.676923076923075,
"alnum_prop": 0.6604614577871002,
"repo_name": "inkasjasonk/rs",
"id": "7f461c15163dea98a7794afc7eccd0e0d32236b0",
"size": "3814",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "research/base/forms.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "JavaScript",
"bytes": "190435"
},
{
"name": "Python",
"bytes": "43798"
},
{
"name": "Ruby",
"bytes": "1462"
},
{
"name": "Shell",
"bytes": "2438"
}
],
"symlink_target": ""
} |
import numpy as np
import scipy.stats
from scipy.interpolate import interp1d, UnivariateSpline
NFILES = 5
FILENAME = "omw_" # prefix for files followed by filenumber
class Prior_class(object):
'''Prior class'''
def __init__(self,priorname,hyperparams):
'''Input:
priorname - array of keywords ["uniform, "gauss"] for each param
hyperparams - array of arrays [[min,max], [mu, variance],...] for each param
'''
self.priorname=priorname
self.hyperparams = hyperparams
if self.priorname == "nonstandard": #first hyperparam = column from file to be read, specify filename and number of files above
'''useful for sampling from non-standard discrete pdf e.g. Planck/WMAP chain'''
self.read_data(hyperparams[0])
self.inv_transform_spline()
self.pdf_spline()
def read_data(self,colnum):
'''Only for "nonstandard". Method to read discrete pdf for parameter from file
Input: colnum: column number to be read from file
'''
self.param=[]
for i in range(1,NFILES):
d = np.loadtxt(FILENAME+str(i)+".txt")
for j in range(len(d[:,colnum])):
self.param.append(d[:,colnum][j])
def inv_transform_spline(self):
'''Only for "nonstandard". Method to create inverse spline to discrete cumulative distribution function
to allow drawing random variables.
Warning: user should check that spline faithfully matches actual cdf.
'''
srt_param=np.sort(self.param)
cdf = np.array(range(len(self.param)))/float(len(self.param))
#create a spline
self.spline2_cdf = UnivariateSpline(cdf,srt_param,k=5)
def pdf_spline(self):
'''Only for "nonstandard". Method creates a spline to the normalised PDF for discrete parameter values.
Warning: user should check that spline faithfully matches actual pdf.
'''
hist,nbins = np.histogram(self.param,normed=True,bins=200)
self.spline2_pdf = interp1d(nbins[1:],hist)
def return_priorprob(self,value):
'''Input:
value - random variable
Returns:
probability of rv given the prior dist
'''
if self.priorname =="gamma":
x = 1./self.hyperparams[1]
return scipy.stats.gamma.pdf(value, self.hyperparams[0],scale=x)
elif self.priorname =="normal":
return scipy.stats.norm.pdf(value, loc = self.hyperparams[0],scale=self.hyperparams[1])
elif self.priorname =="uniform":
width = self.hyperparams[1] - self.hyperparams[0]
return scipy.stats.uniform.pdf(value, loc = self.hyperparams[0],scale=width)
elif self.priorname == "nonstandard":
return self.spline2_pdf(value)
def prior(self):
'''
Returns a random variable from the prior distribution
'''
np.random.seed()
if self.priorname =="gamma":
k=self.hyperparams[0]
scale = 1./self.hyperparams[1]
return float(np.random.gamma(k,scale))
elif self.priorname =="normal":
return float(np.random.normal(self.hyperparams[0],self.hyperparams[1],size=1))
elif self.priorname =="uniform":
return float(np.random.uniform(low=self.hyperparams[0],high=self.hyperparams[1],size=1))
elif self.priorname == "nonstandard":
uni_rvs = np.random.uniform()
return float(self.spline2_cdf(uni_rvs))
| {
"content_hash": "fb1c88f52c9cafb31f30e623baf57ef2",
"timestamp": "",
"source": "github",
"line_count": 84,
"max_line_length": 143,
"avg_line_length": 49.44047619047619,
"alnum_prop": 0.5294967493378281,
"repo_name": "EliseJ/astroABC",
"id": "a0cdc22d63c8168222c07305e7842bca240718f5",
"size": "4153",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "astroabc/priors.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "66042"
}
],
"symlink_target": ""
} |
from rest_framework import serializers
from permabots.models import TelegramUser, TelegramChat, TelegramMessage, TelegramUpdate, TelegramCallbackQuery
from datetime import datetime
import time
class UserSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.IntegerField()
class Meta:
model = TelegramUser
fields = ('id', 'first_name', 'last_name', 'username')
class ChatSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.IntegerField()
class Meta:
model = TelegramChat
fields = ('id', 'type', 'title', 'username', 'first_name', 'last_name')
class TimestampField(serializers.Field):
def to_internal_value(self, data):
return datetime.fromtimestamp(data)
def to_representation(self, value):
return int(time.mktime(value.timetuple()))
class MessageSerializer(serializers.HyperlinkedModelSerializer):
message_id = serializers.IntegerField()
# reserved word field 'from' changed dynamically
from_ = UserSerializer(many=False, source="from_user")
chat = ChatSerializer(many=False)
date = TimestampField()
def __init__(self, *args, **kwargs):
super(MessageSerializer, self).__init__(*args, **kwargs)
self.fields['from'] = self.fields['from_']
del self.fields['from_']
class Meta:
model = TelegramMessage
fields = ('message_id', 'from_', 'date', 'chat', 'text')
validators = []
class CallbackQuerySerializer(serializers.HyperlinkedModelSerializer):
from_ = UserSerializer(many=False, source="from_user")
message = MessageSerializer(many=False, required=False)
id = serializers.CharField(source="callback_id")
def __init__(self, *args, **kwargs):
super(CallbackQuerySerializer, self).__init__(*args, **kwargs)
self.fields['from'] = self.fields['from_']
del self.fields['from_']
class Meta:
model = TelegramCallbackQuery
fields = ('id', 'message', 'from_', 'data')
validators = []
class UpdateSerializer(serializers.HyperlinkedModelSerializer):
update_id = serializers.IntegerField()
message = MessageSerializer(many=False, required=False)
callback_query = CallbackQuerySerializer(many=False, required=False)
class Meta:
model = TelegramUpdate
fields = ('update_id', 'message', 'callback_query')
validators = []
class UserAPISerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = TelegramUser
fields = ('first_name', 'last_name', 'username') | {
"content_hash": "b5d1b40f3ae71c0198c1eed9eda20574",
"timestamp": "",
"source": "github",
"line_count": 76,
"max_line_length": 111,
"avg_line_length": 34.8421052631579,
"alnum_prop": 0.6623867069486404,
"repo_name": "jlmadurga/permabots",
"id": "970a5a46fafcae5bbc6c304e8016cbed6548e44f",
"size": "2648",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "permabots/serializers/telegram_api.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "Makefile",
"bytes": "1236"
},
{
"name": "Python",
"bytes": "496583"
}
],
"symlink_target": ""
} |
import datetime as dt
from operator import attrgetter
from random import Random
from .base import TohuBaseGenerator, SeedGenerator
from .logging import logger
from .primitive_generators import as_tohu_generator, Constant, Date, Timestamp as TimestampPrimitive
from .spawn_mapping import SpawnMapping
from .utils import TohuDateError, TohuTimestampError, ensure_is_date_object, make_timestamp_formatter
__all__ = ['Apply', 'Cumsum', 'GetAttribute', 'Integer', 'Lookup', 'MultiCumsum', 'SelectMultiple', 'SelectOne', 'Tee', 'Timestamp']
class DerivedGenerator(TohuBaseGenerator):
"""
Base class for all derived generators
"""
def reset_input_generators(self, seed):
"""
Helper method which explicitly resets all input generators
to the derived generator. This should only ever be called
for testing or debugging.
"""
seed_generator = SeedGenerator().reset(seed=seed)
for gen in self.input_generators:
gen.reset(next(seed_generator))
try:
# In case `gen` is itself a derived generator,
# recursively reset its own input generators.
gen.reset_input_generators(next(seed_generator))
except AttributeError:
pass
class Apply(DerivedGenerator):
"""
Generator which applies a callable to a elements produced by a set of input generators.
"""
def __init__(self, callable, *arg_gens, max_value=None, **kwarg_gens):
super().__init__()
self.callable = callable
self.arg_gens_orig = arg_gens
self.kwarg_gens_orig = kwarg_gens
self.max_value = max_value
self.arg_gens = [g.clone() for g in self.arg_gens_orig]
self.kwarg_gens = {name: g.clone() for name, g in self.kwarg_gens_orig.items()}
self.input_generators = [g for g in self.arg_gens_orig] + [g for g in self.kwarg_gens_orig.values()]
self.constituent_generators = [g for g in self.arg_gens] + [g for g in self.kwarg_gens.values()]
for gen in self.constituent_generators:
gen.owner = self
def __next__(self):
args = [next(g) for g in self.arg_gens]
kwargs = {name: next(g) for name, g in self.kwarg_gens.items()}
return self.callable(*args, **kwargs)
def reset(self, seed):
super().reset(seed)
try:
self.callable.reset(next(self.seed_generator))
except AttributeError:
logger.debug(
f"Failed to reset callable in generator {self}. Assuming that "
"it does not contain any random generators that need resetting."
)
return self
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_arg_gens_orig = [spawn_mapping[g] for g in self.arg_gens_orig]
new_kwarg_gens_orig = {name: spawn_mapping[g] for name, g in self.kwarg_gens_orig}
new_obj = Apply(self.callable, *new_arg_gens_orig, max_value=self.max_value, **new_kwarg_gens_orig)
new_obj._set_random_state_from(self)
return new_obj
def _set_random_state_from(self, other):
for g_self, g_other in zip(self.constituent_generators, other.constituent_generators):
g_self._set_random_state_from(g_other)
class GetAttribute(Apply):
def __init__(self, g, name):
self.g = as_tohu_generator(g) # no need to clone here because this happens in the superclass
self.name = as_tohu_generator(name)
def func(value, name):
# TODO: this is not very efficient if `name` is a constant
# string because we're re-creating the attrgetter every time.
# However, since `name` can in principle be a generator itself
# we need to keep the generality.
f = attrgetter(name)
try:
return f(value)
except AttributeError:
try:
return [f(x) for x in value]
except TypeError:
raise AttributeError(f"Could not extract attribute '{name}' from {value}")
except AttributeError:
raise AttributeError(f"Could not extract attribute '{name}' from items in sequence: {value}")
super().__init__(func, self.g, self.name)
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = GetAttribute(spawn_mapping[self.g], spawn_mapping[self.name])
new_obj._set_random_state_from(self)
return new_obj
def reset(self, seed):
super().reset(seed)
self.g.reset(seed)
return self
class Lookup(Apply):
"""
Generator which performs a lookup of elements produced by another generator.
"""
def __init__(self, key, mapping):
self.key = as_tohu_generator(key)
self.mapping = as_tohu_generator(mapping)
def f_lookup(key, mapping):
return mapping[key]
super().__init__(f_lookup, self.key, self.mapping)
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = Lookup(spawn_mapping[self.key], spawn_mapping[self.mapping])
new_obj._set_random_state_from(self)
return new_obj
class Integer(Apply):
def __init__(self, low, high):
self.low_gen = as_tohu_generator(low)
self.high_gen = as_tohu_generator(high)
self.randgen = Random()
super().__init__(self.randgen.randint, self.low_gen, self.high_gen)
self.max_value = self.high_gen.max_value
def reset(self, seed):
super().reset(seed)
self.randgen.seed(next(self.seed_generator))
return self
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = Integer(spawn_mapping[self.low_gen], spawn_mapping[self.high_gen])
new_obj._set_random_state_from(self)
return new_obj
def _set_random_state_from(self, other):
super()._set_random_state_from(other)
self.randgen.setstate(other.randgen.getstate())
class SelectOne(Apply):
"""
Generator which selects a single element from each sequence produced by another generator.
"""
def __init__(self, values, p=None):
self.values_gen = as_tohu_generator(values)
self.p_gen = as_tohu_generator(p)
self.randgen = Random()
def func(values, p):
return self.randgen.choices(values, weights=p)[0]
super().__init__(func, self.values_gen, self.p_gen)
def reset(self, seed):
super().reset(seed)
self.randgen.seed(seed)
return self
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = SelectOne(spawn_mapping[self.values_gen], p=spawn_mapping[self.p_gen])
new_obj._set_random_state_from(self)
return new_obj
def _set_random_state_from(self, other):
super()._set_random_state_from(other)
self.randgen.setstate(other.randgen.getstate())
def _spot_check_that_elements_produced_by_this_generator_have_attribute(self, name):
"""
Helper function to spot-check that the items produces by this generator have the attribute `name`.
"""
g_tmp = self.values_gen.spawn()
sample_element = next(g_tmp)[0]
try:
getattr(sample_element, name)
except AttributeError:
raise AttributeError(f"Items produced by {self} do not have the attribute '{name}'")
def __getattr__(self, name):
self._spot_check_that_elements_produced_by_this_generator_have_attribute(name)
return GetAttribute(self, name)
class SelectMultiple(Apply):
"""
Generator which selects multiple elements (without replacement)
from each sequence produced by another generator.
"""
def __init__(self, values, num):
self.values_gen = as_tohu_generator(values)
self.num_gen = as_tohu_generator(num)
self.randgen = Random()
func = self.randgen.sample
super().__init__(func, self.values_gen, k=self.num_gen)
def reset(self, seed):
super().reset(seed)
self.randgen.seed(seed)
return self
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = SelectMultiple(spawn_mapping[self.values_gen], spawn_mapping[self.num_gen])
new_obj._set_random_state_from(self)
return new_obj
def _set_random_state_from(self, other):
super()._set_random_state_from(other)
self.randgen.setstate(other.randgen.getstate())
def size(self):
def get_size(x):
return len(x)
g = Apply(get_size, self, max_value=self.num_gen.max_value)
return g
class Tee(Apply):
def __init__(self, g, num):
self.g_orig = g
self.num_gen = as_tohu_generator(num)
self.value_gens = [g.spawn() for _ in range(self.num_gen.max_value)]
if self.num_gen.max_value > 1000:
raise NotImplementedError(
"This Tee generator is intended to be used to produce small-ish output tuples. "
"The current implementation is not ideal for potentially large tuples, which"
"which is why we only allow sizes up to 1000 elements at the moment."
)
def make_tuple(num, *values):
return tuple(values[:num])
super().__init__(make_tuple, self.num_gen, *self.value_gens)
def reset(self, seed):
super().reset(seed)
# We need to explicitly reset the value generators because they
# are not technically input generators to this derived generator
# so they can't be externally reset.
for g in self.value_gens:
g.reset(next(self.seed_generator))
return self
def convert_to_date_object(date):
if isinstance(date, Constant):
return convert_to_date_object(date.value)
elif isinstance(date, Date) and date.start == date.end:
return date.start
else:
try:
return ensure_is_date_object(date)
except TohuDateError:
raise TohuTimestampError(f"Argument 'date' must represent some kind of constant date object. Got: {date}")
def get_start_generator(start, date):
if date is not None:
date = convert_to_date_object(date)
if start is None:
start_value = dt.datetime(date.year, date.month, date.day)
start_gen = Constant(start_value)
elif isinstance(start, str):
start_value = dt.datetime.strptime(start, "%Y-%m-%d %H:%M:%S")
start_gen = Constant(start_value)
elif isinstance(start, dt.datetime):
return Constant(start)
elif isinstance(start, Constant):
return get_start_generator(start.value, date)
elif isinstance(start, TimestampPrimitive):
# Create a new generator to strip any string formatting information in case it exists
start_without_formatting = TimestampPrimitive(start=start.start, end=start.end)
start.register_clone(start_without_formatting)
start_without_formatting.register_parent(start)
return start_without_formatting
else:
raise NotImplementedError()
return start_gen
def get_end_generator(end, date):
if date is not None:
date = convert_to_date_object(date)
if end is None:
end_value = dt.datetime(date.year, date.month, date.day, 23, 59, 59)
end_gen = Constant(end_value)
elif isinstance(end, str):
end_value = dt.datetime.strptime(end, "%Y-%m-%d %H:%M:%S")
end_gen = Constant(end_value)
elif isinstance(end, dt.datetime):
return Constant(end)
elif isinstance(end, Constant):
return get_start_generator(end.value, date)
elif isinstance(end, TimestampPrimitive):
# Create a new generator to strip any string formatting information in case it exists
end_without_formatting = TimestampPrimitive(start=end.start, end=end.end)
end.register_clone(end_without_formatting)
end_without_formatting.register_parent(end)
return end_without_formatting
else:
raise NotImplementedError()
return end_gen
def get_start_end_end_generator(start, end, date):
start_gen = get_start_generator(start, date)
end_gen = get_end_generator(end, date)
return start_gen, end_gen
def check_valid_inputs(start_gen, end_gen, date):
if date is not None:
date = convert_to_date_object(date)
if date is not None:
if isinstance(start_gen, TimestampPrimitive):
if not (start_gen.start.date() == date and start_gen.end.date() == date):
raise TohuTimestampError(
"If the 'date' argument is given, all possible 'start' timestamp values must lie on that given date."
)
if isinstance(end_gen, TimestampPrimitive):
if not (end_gen.start.date() == date and end_gen.end.date() == date):
raise TohuTimestampError(
"If the 'date' argument is given, all possible 'end' timestamp values must lie on that given date."
)
start_end_error_msg = (
"Latest possible value of 'start' generator must not be after "
"earliest possible value of 'end' generator."
)
if isinstance(start_gen, TimestampPrimitive) and isinstance(end_gen, TimestampPrimitive):
if start_gen.end > end_gen.start:
raise TohuTimestampError(start_end_error_msg)
elif isinstance(start_gen, TimestampPrimitive) and isinstance(end_gen, Constant):
if start_gen.end > end_gen.value:
raise TohuTimestampError(start_end_error_msg)
elif isinstance(start_gen, Constant) and isinstance(end_gen, TimestampPrimitive):
if start_gen.value > end_gen.start:
raise TohuTimestampError(start_end_error_msg)
elif isinstance(start_gen, Constant) and isinstance(end_gen, Constant):
if start_gen.value> end_gen.value:
raise TohuTimestampError("Start value must be before end value. Got: start={self.start}, end={self.end}")
class Timestamp(Apply):
def __init__(self, *, start=None, end=None, date=None, fmt=None, uppercase=None):
if start is None and end is None and date is None:
raise TohuTimestampError("Not all input arguments can be None.")
if start is not None and end is not None and date is not None:
raise TohuTimestampError("Arguments 'start', 'end', 'date' cannot all be provided.")
self.start_gen, self.end_gen = get_start_end_end_generator(start, end, date)
check_valid_inputs(self.start_gen, self.end_gen, date)
self.offset_randgen = Random()
def func(start, end):
interval = (end - start).total_seconds()
try:
offset = self.offset_randgen.randint(0, interval)
except ValueError:
raise TohuTimestampError(f"Start generator produced timestamp later than end generator: start={start}, end={end}")
ts = (start + dt.timedelta(seconds=offset))
return ts
super().__init__(func, self.start_gen, self.end_gen)
self.max_value = self.end_gen.max_value
self.fmt = fmt
self.uppercase = uppercase
self._maybe_format_timestamp = make_timestamp_formatter(self.fmt, self.uppercase)
def __next__(self):
ts = super().__next__()
return self._maybe_format_timestamp(ts)
def reset(self, seed):
super().reset(seed)
self.offset_randgen.seed(next(self.seed_generator))
return self
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = Timestamp(start=spawn_mapping[self.start_gen], end=spawn_mapping[self.end_gen], fmt=self.fmt, uppercase=self.uppercase)
new_obj._set_random_state_from(self)
return new_obj
def _set_random_state_from(self, other):
super()._set_random_state_from(other)
self.offset_randgen.setstate(other.offset_randgen.getstate())
def strftime(self, fmt='%Y-%m-%d %H:%M:%S', uppercase=False):
g = Timestamp(start=self.start_gen, end=self.end_gen, fmt=fmt, uppercase=uppercase)
self.register_clone(g)
g.register_parent(self)
return g
class Cumsum(DerivedGenerator):
def __init__(self, g, *, start_with_zero=False):
super().__init__()
self.g_orig = g
self.g_internal = g.clone()
self.g_internal.owner = self
self.start_with_zero = start_with_zero
self.input_generators = [self.g_orig]
self.constituent_generators = [self.g_internal]
self.reset()
def __next__(self):
retval = self.value
self.value += next(self.g_internal)
return retval
def reset(self, seed=None):
super().reset(seed)
if self.start_with_zero:
self.value = 0
else:
# Note: for this to work correctly the input generator `g`
# needs to be reset _before_ this one.
self.value = next(self.g_internal)
return self
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = Cumsum(spawn_mapping[self.g_orig], start_with_zero=self.start_with_zero)
new_obj._set_random_state_from(self)
return new_obj
def _set_random_state_from(self, other):
super()._set_random_state_from(other)
self.value = other.value
self.g_internal._set_random_state_from(other.g_internal)
class MultiCumsum(DerivedGenerator):
"""
TODO: document me!
"""
def __init__(self, g, attr_name, g_amount):
"""
TODO: document me!
"""
super().__init__()
self.g_amount_orig = as_tohu_generator(g_amount)
self.g_amount_internal = g_amount.clone()
self.g_amount_internal.owner = self
self.g_orig = g
self.g_internal = g.clone()
self.g_internal.owner = self
self.attr_name = attr_name
self.input_generators = [self.g_amount_orig, self.g_orig]
self.constituent_generators = [self.g_amount_internal, self.g_internal]
self.cur_values = {}
def __next__(self):
# TODO: more meaningful variable names!
x = next(self.g_internal)
try:
cur_val = self.cur_values[x]
except KeyError:
cur_val = getattr(x, self.attr_name)
self.cur_values[x] = cur_val
self.cur_values[x] += next(self.g_amount_internal)
return cur_val
def reset(self, seed=None):
super().reset(seed)
self.cur_values = {}
return self
def spawn(self, spawn_mapping=None):
spawn_mapping = spawn_mapping or SpawnMapping()
new_obj = MultiCumsum(spawn_mapping[self.g_orig], self.attr_name, spawn_mapping[self.g_amount_orig])
new_obj._set_random_state_from(self)
return new_obj
def _set_random_state_from(self, other):
self.g_amount_internal._set_random_state_from(other.g_amount_internal)
self.g_internal._set_random_state_from(other.g_internal)
self.cur_values = other.cur_values.copy() ### XXX TODO: can we simply copy these over in all cases?! | {
"content_hash": "73a438d5e1cb4e348329f45fe138d8f4",
"timestamp": "",
"source": "github",
"line_count": 539,
"max_line_length": 137,
"avg_line_length": 36.137291280148425,
"alnum_prop": 0.6247047951535065,
"repo_name": "maxalbert/tohu",
"id": "208c0d93d46c8b6596283d30cdd31a0fd80db364",
"size": "19479",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "tohu/v6/derived_generators.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Jupyter Notebook",
"bytes": "244324"
},
{
"name": "Makefile",
"bytes": "461"
},
{
"name": "Python",
"bytes": "568361"
}
],
"symlink_target": ""
} |
import socket as socketlib
from _udt import *
import _udt
class socket(_udt.socket):
def connect(self, addr):
conn_addr = self._get_addr(addr)
return _udt.socket.connect(self, conn_addr)
def bind(self, addr):
bind_addr = self._get_addr(addr)
return _udt.socket.bind(self, bind_addr)
def _get_addr(self, (host, port)):
family, socktype, proto, name, addr = socketlib.getaddrinfo(
host,
port,
self.family,
0,
self.proto,
0
)[0]
return addr
class epoll(_udt.epoll):
def __init__(self):
_udt.epoll.__init__(self)
self._released = False
def release(self):
if not self._released:
_udt.epoll.release(self)
def add_usock(self, s, events):
# according to the docs, adding flags is not supported
rv = _udt.epoll.add_usock(self, s, events)
return rv
def add_ssock(self, s, events):
rv = _udt.epoll.add_ssock(self, s, events)
return rv
def remove_usock(self, s, events):
rv = _udt.epoll.remove_usock(self, s, events)
return rv
def remove_ssock(self, s, events):
rv = _udt.epoll.remove_ssock(self, s, events)
return rv
| {
"content_hash": "078832d59938330a352458bb3b0b0c7e",
"timestamp": "",
"source": "github",
"line_count": 49,
"max_line_length": 68,
"avg_line_length": 26.551020408163264,
"alnum_prop": 0.5541890853189854,
"repo_name": "beano/udt_py",
"id": "e6dff33b0395afeb4c167f25a3644b9a9fe270cc",
"size": "1357",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "udt.py",
"mode": "33188",
"license": "bsd-3-clause",
"language": [
{
"name": "C++",
"bytes": "35679"
},
{
"name": "Python",
"bytes": "10536"
}
],
"symlink_target": ""
} |
import sys
import logging
import argparse
import getpass
from drf_client.connection import Api as RestApi, DEFAULT_HEADERS
from drf_client.exceptions import HttpClientError
LOG = logging.getLogger(__name__)
class BaseMain(object):
parser = None
args = None
api = None
options = {
'DOMAIN': None,
'API_PREFIX': 'api/v1',
'TOKEN_TYPE': 'jwt',
'TOKEN_FORMAT': 'JWT {token}',
'USERNAME_KEY': 'username',
'LOGIN': 'auth/login/',
'LOGOUT': 'auth/logout/',
'USE_DASHES': False,
}
logging_level = logging.INFO
def __init__(self):
"""
Initialize Logging configuration
Initialize argument parsing
Process any extra arguments
Only hard codes one required argument: --user
Additional arguments can be configured by overwriting the add_extra_args() method
Logging configuration can be changed by overwritting the config_logging() method
"""
self.parser = argparse.ArgumentParser(description=__doc__)
self.parser.add_argument(
'-u', '--user', dest='username', type=str, required=True,
help='Username used for login'
)
self.parser.add_argument(
'--server', dest='server', type=str, required=True,
help='Server Domain Name to use'
)
self.add_extra_args()
self.args = self.parser.parse_args()
self.config_logging()
def _critical_exit(self, msg):
LOG.error(msg)
sys.exit(1)
def main(self):
"""
Main function to call to initiate execution.
1. Get domain name and use to instantiate Api object
2. Call before_login to allow for work before logging in
3. Logging into the server
4. Call after_loging to do actual work with server data
"""
self.domain = self.get_domain()
self.api = RestApi(self.get_options())
self.before_login()
ok = self.login()
if ok:
self.after_login()
# Following functions can be overwritten if needed
# ================================================
def get_options(self):
options = self.options
options['DOMAIN'] = self.domain
return options
def config_logging(self):
"""
Overwrite to change the way the logging package is configured
:return: Nothing
"""
logging.basicConfig(level=self.logging_level,
format='[%(asctime)-15s] %(levelname)-6s %(message)s',
datefmt='%d/%b/%Y %H:%M:%S')
def add_extra_args(self):
"""
Overwrite to change the way extra arguments are added to the args parser
:return: Nothing
"""
pass
def get_domain(self) -> str:
"""
Figure out server domain URL based on --server and --customer args
"""
if 'https://' not in self.args.server:
return f'https://{self.args.server}'
return self.args.server
def login(self) -> bool:
"""
Get password from user and login
"""
password = getpass.getpass()
ok = self.api.login(username=self.args.username, password=password)
if ok:
LOG.info('Welcome {0}'.format(self.args.username))
return ok
def before_login(self):
"""
Overwrite to do work after parsing, but before logging in to the server
This is a good place to do additional custom argument checks
:return: Nothing
"""
pass
def after_login(self):
"""
This function MUST be overwritten to do actual work after logging into the Server
:return: Nothing
"""
LOG.warning('No actual work done')
| {
"content_hash": "5bb94fb2300afdb8e69b7cbf9de69579",
"timestamp": "",
"source": "github",
"line_count": 126,
"max_line_length": 89,
"avg_line_length": 30.38095238095238,
"alnum_prop": 0.5715778474399164,
"repo_name": "dkarchmer/django-rest-framework-client",
"id": "bc9af33e00b604d54a13cad007e7788d2e2e6a12",
"size": "3828",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "drf_client/helpers/base_main.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "26778"
}
],
"symlink_target": ""
} |
from rip.schema.base_field import FieldTypes
from rip.schema.integer_field import IntegerField
class IdField(IntegerField):
def __init__(self, entity_attribute='id'):
super(IdField, self).__init__(field_type=FieldTypes.READONLY,
required=False,
nullable=False,
entity_attribute=entity_attribute
)
| {
"content_hash": "4478c92d7b0759aea3f4ca44d7a8a17e",
"timestamp": "",
"source": "github",
"line_count": 11,
"max_line_length": 71,
"avg_line_length": 42.09090909090909,
"alnum_prop": 0.509719222462203,
"repo_name": "Aplopio/rip",
"id": "0cebc72982f2adcd30d21c2d241e20a3d76e19fb",
"size": "463",
"binary": false,
"copies": "2",
"ref": "refs/heads/master",
"path": "rip/schema/id_field.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Makefile",
"bytes": "1455"
},
{
"name": "Python",
"bytes": "409017"
}
],
"symlink_target": ""
} |
import _plotly_utils.basevalidators
class ExponentformatValidator(_plotly_utils.basevalidators.EnumeratedValidator):
def __init__(
self, plotly_name="exponentformat", parent_name="carpet.baxis", **kwargs
):
super(ExponentformatValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "calc"),
role=kwargs.pop("role", "style"),
values=kwargs.pop("values", ["none", "e", "E", "power", "SI", "B"]),
**kwargs
)
| {
"content_hash": "841514c363f45573b3f107841dd05076",
"timestamp": "",
"source": "github",
"line_count": 15,
"max_line_length": 80,
"avg_line_length": 37.8,
"alnum_prop": 0.5873015873015873,
"repo_name": "plotly/python-api",
"id": "48096e5970f9bb6efb36f727f9ca27822d939c7f",
"size": "567",
"binary": false,
"copies": "1",
"ref": "refs/heads/master",
"path": "packages/python/plotly/plotly/validators/carpet/baxis/_exponentformat.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "JavaScript",
"bytes": "6870"
},
{
"name": "Makefile",
"bytes": "1708"
},
{
"name": "Python",
"bytes": "823245"
},
{
"name": "Shell",
"bytes": "3238"
}
],
"symlink_target": ""
} |
from __future__ import unicode_literals
import base64
import codecs
import datetime
import distutils.util
from email import message_from_file
import hashlib
import imp
import json
import logging
import os
import posixpath
import re
import shutil
import sys
import tempfile
import zipfile
from . import __version__, DistlibException
from .compat import sysconfig, ZipFile, fsdecode, text_type, filter
from .database import InstalledDistribution
from .metadata import Metadata, METADATA_FILENAME
from .util import (FileOperator, convert_path, CSVReader, CSVWriter, Cache,
cached_property, get_cache_base, read_exports, tempdir)
from .version import NormalizedVersion, UnsupportedVersionError
logger = logging.getLogger(__name__)
cache = None # created when needed
if hasattr(sys, 'pypy_version_info'):
IMP_PREFIX = 'pp'
elif sys.platform.startswith('java'):
IMP_PREFIX = 'jy'
elif sys.platform == 'cli':
IMP_PREFIX = 'ip'
else:
IMP_PREFIX = 'cp'
VER_SUFFIX = sysconfig.get_config_var('py_version_nodot')
if not VER_SUFFIX: # pragma: no cover
VER_SUFFIX = '%s%s' % sys.version_info[:2]
PYVER = 'py' + VER_SUFFIX
IMPVER = IMP_PREFIX + VER_SUFFIX
ARCH = distutils.util.get_platform().replace('-', '_').replace('.', '_')
ABI = sysconfig.get_config_var('SOABI')
if ABI and ABI.startswith('cpython-'):
ABI = ABI.replace('cpython-', 'cp')
else:
def _derive_abi():
parts = ['cp', VER_SUFFIX]
if sysconfig.get_config_var('Py_DEBUG'):
parts.append('d')
if sysconfig.get_config_var('WITH_PYMALLOC'):
parts.append('m')
if sysconfig.get_config_var('Py_UNICODE_SIZE') == 4:
parts.append('u')
return ''.join(parts)
ABI = _derive_abi()
del _derive_abi
FILENAME_RE = re.compile(r'''
(?P<nm>[^-]+)
-(?P<vn>\d+[^-]*)
(-(?P<bn>\d+[^-]*))?
-(?P<py>\w+\d+(\.\w+\d+)*)
-(?P<bi>\w+)
-(?P<ar>\w+)
\.whl$
''', re.IGNORECASE | re.VERBOSE)
NAME_VERSION_RE = re.compile(r'''
(?P<nm>[^-]+)
-(?P<vn>\d+[^-]*)
(-(?P<bn>\d+[^-]*))?$
''', re.IGNORECASE | re.VERBOSE)
SHEBANG_RE = re.compile(br'\s*#![^\r\n]*')
if os.sep == '/':
to_posix = lambda o: o
else:
to_posix = lambda o: o.replace(os.sep, '/')
class Mounter(object):
def __init__(self):
self.impure_wheels = {}
self.libs = {}
def add(self, pathname, extensions):
self.impure_wheels[pathname] = extensions
self.libs.update(extensions)
def remove(self, pathname):
extensions = self.impure_wheels.pop(pathname)
for k, v in extensions:
if k in self.libs:
del self.libs[k]
def find_module(self, fullname, path=None):
if fullname in self.libs:
result = self
else:
result = None
return result
def load_module(self, fullname):
if fullname in sys.modules:
result = sys.modules[fullname]
else:
if fullname not in self.libs:
raise ImportError('unable to find extension for %s' % fullname)
result = imp.load_dynamic(fullname, self.libs[fullname])
result.__loader__ = self
parts = fullname.rsplit('.', 1)
if len(parts) > 1:
result.__package__ = parts[0]
return result
_hook = Mounter()
class Wheel(object):
"""
Class to build and install from Wheel files (PEP 427).
"""
wheel_version = (1, 1)
hash_kind = 'sha256'
def __init__(self, filename=None, sign=False, verify=False):
"""
Initialise an instance using a (valid) filename.
"""
self.sign = sign
self.should_verify = verify
self.buildver = ''
self.pyver = [PYVER]
self.abi = ['none']
self.arch = ['any']
self.dirname = os.getcwd()
if filename is None:
self.name = 'dummy'
self.version = '0.1'
self._filename = self.filename
else:
m = NAME_VERSION_RE.match(filename)
if m:
info = m.groupdict('')
self.name = info['nm']
# Reinstate the local version separator
self.version = info['vn'].replace('_', '-')
self.buildver = info['bn']
self._filename = self.filename
else:
dirname, filename = os.path.split(filename)
m = FILENAME_RE.match(filename)
if not m:
raise DistlibException('Invalid name or '
'filename: %r' % filename)
if dirname:
self.dirname = os.path.abspath(dirname)
self._filename = filename
info = m.groupdict('')
self.name = info['nm']
self.version = info['vn']
self.buildver = info['bn']
self.pyver = info['py'].split('.')
self.abi = info['bi'].split('.')
self.arch = info['ar'].split('.')
@property
def filename(self):
"""
Build and return a filename from the various components.
"""
if self.buildver:
buildver = '-' + self.buildver
else:
buildver = ''
pyver = '.'.join(self.pyver)
abi = '.'.join(self.abi)
arch = '.'.join(self.arch)
# replace - with _ as a local version separator
version = self.version.replace('-', '_')
return '%s-%s%s-%s-%s-%s.whl' % (self.name, version, buildver,
pyver, abi, arch)
@property
def exists(self):
path = os.path.join(self.dirname, self.filename)
return os.path.isfile(path)
@property
def tags(self):
for pyver in self.pyver:
for abi in self.abi:
for arch in self.arch:
yield pyver, abi, arch
@cached_property
def metadata(self):
pathname = os.path.join(self.dirname, self.filename)
name_ver = '%s-%s' % (self.name, self.version)
info_dir = '%s.dist-info' % name_ver
wrapper = codecs.getreader('utf-8')
with ZipFile(pathname, 'r') as zf:
wheel_metadata = self.get_wheel_metadata(zf)
wv = wheel_metadata['Wheel-Version'].split('.', 1)
file_version = tuple([int(i) for i in wv])
if file_version < (1, 1):
fn = 'METADATA'
else:
fn = METADATA_FILENAME
try:
metadata_filename = posixpath.join(info_dir, fn)
with zf.open(metadata_filename) as bf:
wf = wrapper(bf)
result = Metadata(fileobj=wf)
except KeyError:
raise ValueError('Invalid wheel, because %s is '
'missing' % fn)
return result
def get_wheel_metadata(self, zf):
name_ver = '%s-%s' % (self.name, self.version)
info_dir = '%s.dist-info' % name_ver
metadata_filename = posixpath.join(info_dir, 'WHEEL')
with zf.open(metadata_filename) as bf:
wf = codecs.getreader('utf-8')(bf)
message = message_from_file(wf)
return dict(message)
@cached_property
def info(self):
pathname = os.path.join(self.dirname, self.filename)
with ZipFile(pathname, 'r') as zf:
result = self.get_wheel_metadata(zf)
return result
def process_shebang(self, data):
m = SHEBANG_RE.match(data)
if m:
data = b'#!python' + data[m.end():]
else:
cr = data.find(b'\r')
lf = data.find(b'\n')
if cr < 0 or cr > lf:
term = b'\n'
else:
if data[cr:cr + 2] == b'\r\n':
term = b'\r\n'
else:
term = b'\r'
data = b'#!python' + term + data
return data
def get_hash(self, data, hash_kind=None):
if hash_kind is None:
hash_kind = self.hash_kind
try:
hasher = getattr(hashlib, hash_kind)
except AttributeError:
raise DistlibException('Unsupported hash algorithm: %r' % hash_kind)
result = hasher(data).digest()
result = base64.urlsafe_b64encode(result).rstrip(b'=').decode('ascii')
return hash_kind, result
def write_record(self, records, record_path, base):
with CSVWriter(record_path) as writer:
for row in records:
writer.writerow(row)
p = to_posix(os.path.relpath(record_path, base))
writer.writerow((p, '', ''))
def write_records(self, info, libdir, archive_paths):
records = []
distinfo, info_dir = info
hasher = getattr(hashlib, self.hash_kind)
for ap, p in archive_paths:
with open(p, 'rb') as f:
data = f.read()
digest = '%s=%s' % self.get_hash(data)
size = os.path.getsize(p)
records.append((ap, digest, size))
p = os.path.join(distinfo, 'RECORD')
self.write_record(records, p, libdir)
ap = to_posix(os.path.join(info_dir, 'RECORD'))
archive_paths.append((ap, p))
def build_zip(self, pathname, archive_paths):
with ZipFile(pathname, 'w', zipfile.ZIP_DEFLATED) as zf:
for ap, p in archive_paths:
logger.debug('Wrote %s to %s in wheel', p, ap)
zf.write(p, ap)
def build(self, paths, tags=None, wheel_version=None):
"""
Build a wheel from files in specified paths, and use any specified tags
when determining the name of the wheel.
"""
if tags is None:
tags = {}
libkey = list(filter(lambda o: o in paths, ('purelib', 'platlib')))[0]
if libkey == 'platlib':
is_pure = 'false'
default_pyver = [IMPVER]
default_abi = [ABI]
default_arch = [ARCH]
else:
is_pure = 'true'
default_pyver = [PYVER]
default_abi = ['none']
default_arch = ['any']
self.pyver = tags.get('pyver', default_pyver)
self.abi = tags.get('abi', default_abi)
self.arch = tags.get('arch', default_arch)
libdir = paths[libkey]
name_ver = '%s-%s' % (self.name, self.version)
data_dir = '%s.data' % name_ver
info_dir = '%s.dist-info' % name_ver
archive_paths = []
# First, stuff which is not in site-packages
for key in ('data', 'headers', 'scripts'):
if key not in paths:
continue
path = paths[key]
if os.path.isdir(path):
for root, dirs, files in os.walk(path):
for fn in files:
p = fsdecode(os.path.join(root, fn))
rp = os.path.relpath(p, path)
ap = to_posix(os.path.join(data_dir, key, rp))
archive_paths.append((ap, p))
if key == 'scripts' and not p.endswith('.exe'):
with open(p, 'rb') as f:
data = f.read()
data = self.process_shebang(data)
with open(p, 'wb') as f:
f.write(data)
# Now, stuff which is in site-packages, other than the
# distinfo stuff.
path = libdir
distinfo = None
for root, dirs, files in os.walk(path):
if root == path:
# At the top level only, save distinfo for later
# and skip it for now
for i, dn in enumerate(dirs):
dn = fsdecode(dn)
if dn.endswith('.dist-info'):
distinfo = os.path.join(root, dn)
del dirs[i]
break
assert distinfo, '.dist-info directory expected, not found'
for fn in files:
# comment out next suite to leave .pyc files in
if fsdecode(fn).endswith(('.pyc', '.pyo')):
continue
p = os.path.join(root, fn)
rp = to_posix(os.path.relpath(p, path))
archive_paths.append((rp, p))
# Now distinfo. Assumed to be flat, i.e. os.listdir is enough.
files = os.listdir(distinfo)
for fn in files:
if fn not in ('RECORD', 'INSTALLER', 'SHARED', 'WHEEL'):
p = fsdecode(os.path.join(distinfo, fn))
ap = to_posix(os.path.join(info_dir, fn))
archive_paths.append((ap, p))
wheel_metadata = [
'Wheel-Version: %d.%d' % (wheel_version or self.wheel_version),
'Generator: distlib %s' % __version__,
'Root-Is-Purelib: %s' % is_pure,
]
for pyver, abi, arch in self.tags:
wheel_metadata.append('Tag: %s-%s-%s' % (pyver, abi, arch))
p = os.path.join(distinfo, 'WHEEL')
with open(p, 'w') as f:
f.write('\n'.join(wheel_metadata))
ap = to_posix(os.path.join(info_dir, 'WHEEL'))
archive_paths.append((ap, p))
# Now, at last, RECORD.
# Paths in here are archive paths - nothing else makes sense.
self.write_records((distinfo, info_dir), libdir, archive_paths)
# Now, ready to build the zip file
pathname = os.path.join(self.dirname, self.filename)
self.build_zip(pathname, archive_paths)
return pathname
def install(self, paths, maker, **kwargs):
"""
Install a wheel to the specified paths. If kwarg ``warner`` is
specified, it should be a callable, which will be called with two
tuples indicating the wheel version of this software and the wheel
version in the file, if there is a discrepancy in the versions.
This can be used to issue any warnings to raise any exceptions.
If kwarg ``lib_only`` is True, only the purelib/platlib files are
installed, and the headers, scripts, data and dist-info metadata are
not written.
The return value is a :class:`InstalledDistribution` instance unless
``options.lib_only`` is True, in which case the return value is ``None``.
"""
dry_run = maker.dry_run
warner = kwargs.get('warner')
lib_only = kwargs.get('lib_only', False)
pathname = os.path.join(self.dirname, self.filename)
name_ver = '%s-%s' % (self.name, self.version)
data_dir = '%s.data' % name_ver
info_dir = '%s.dist-info' % name_ver
metadata_name = posixpath.join(info_dir, METADATA_FILENAME)
wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
record_name = posixpath.join(info_dir, 'RECORD')
wrapper = codecs.getreader('utf-8')
with ZipFile(pathname, 'r') as zf:
with zf.open(wheel_metadata_name) as bwf:
wf = wrapper(bwf)
message = message_from_file(wf)
wv = message['Wheel-Version'].split('.', 1)
file_version = tuple([int(i) for i in wv])
if (file_version != self.wheel_version) and warner:
warner(self.wheel_version, file_version)
if message['Root-Is-Purelib'] == 'true':
libdir = paths['purelib']
else:
libdir = paths['platlib']
records = {}
with zf.open(record_name) as bf:
with CSVReader(stream=bf) as reader:
for row in reader:
p = row[0]
records[p] = row
data_pfx = posixpath.join(data_dir, '')
info_pfx = posixpath.join(info_dir, '')
script_pfx = posixpath.join(data_dir, 'scripts', '')
# make a new instance rather than a copy of maker's,
# as we mutate it
fileop = FileOperator(dry_run=dry_run)
fileop.record = True # so we can rollback if needed
bc = not sys.dont_write_bytecode # Double negatives. Lovely!
outfiles = [] # for RECORD writing
# for script copying/shebang processing
workdir = tempfile.mkdtemp()
# set target dir later
# we default add_launchers to False, as the
# Python Launcher should be used instead
maker.source_dir = workdir
maker.target_dir = None
try:
for zinfo in zf.infolist():
arcname = zinfo.filename
if isinstance(arcname, text_type):
u_arcname = arcname
else:
u_arcname = arcname.decode('utf-8')
# The signature file won't be in RECORD,
# and we don't currently don't do anything with it
if u_arcname.endswith('/RECORD.jws'):
continue
row = records[u_arcname]
if row[2] and str(zinfo.file_size) != row[2]:
raise DistlibException('size mismatch for '
'%s' % u_arcname)
if row[1]:
kind, value = row[1].split('=', 1)
with zf.open(arcname) as bf:
data = bf.read()
_, digest = self.get_hash(data, kind)
if digest != value:
raise DistlibException('digest mismatch for '
'%s' % arcname)
if lib_only and u_arcname.startswith((info_pfx, data_pfx)):
logger.debug('lib_only: skipping %s', u_arcname)
continue
is_script = (u_arcname.startswith(script_pfx)
and not u_arcname.endswith('.exe'))
if u_arcname.startswith(data_pfx):
_, where, rp = u_arcname.split('/', 2)
outfile = os.path.join(paths[where], convert_path(rp))
else:
# meant for site-packages.
if u_arcname in (wheel_metadata_name, record_name):
continue
outfile = os.path.join(libdir, convert_path(u_arcname))
if not is_script:
with zf.open(arcname) as bf:
fileop.copy_stream(bf, outfile)
outfiles.append(outfile)
# Double check the digest of the written file
if not dry_run and row[1]:
with open(outfile, 'rb') as bf:
data = bf.read()
_, newdigest = self.get_hash(data, kind)
if newdigest != digest:
raise DistlibException('digest mismatch '
'on write for '
'%s' % outfile)
if bc and outfile.endswith('.py'):
try:
pyc = fileop.byte_compile(outfile)
outfiles.append(pyc)
except Exception:
# Don't give up if byte-compilation fails,
# but log it and perhaps warn the user
logger.warning('Byte-compilation failed',
exc_info=True)
else:
fn = os.path.basename(convert_path(arcname))
workname = os.path.join(workdir, fn)
with zf.open(arcname) as bf:
fileop.copy_stream(bf, workname)
dn, fn = os.path.split(outfile)
maker.target_dir = dn
filenames = maker.make(fn)
fileop.set_executable_mode(filenames)
outfiles.extend(filenames)
if lib_only:
logger.debug('lib_only: returning None')
dist = None
else:
# Generate scripts
# Try to get pydist.json so we can see if there are
# any commands to generate. If this fails (e.g. because
# of a legacy wheel), log a warning but don't give up.
commands = None
file_version = self.info['Wheel-Version']
if file_version == '1.0':
# Use legacy info
ep = posixpath.join(info_dir, 'entry_points.txt')
try:
with zf.open(ep) as bwf:
epdata = read_exports(bwf)
commands = {}
for key in ('console', 'gui'):
k = '%s_scripts' % key
if k in epdata:
commands['wrap_%s' % key] = d = {}
for v in epdata[k].values():
s = '%s:%s' % (v.prefix, v.suffix)
if v.flags:
s += ' %s' % v.flags
d[v.name] = s
except Exception:
logger.warning('Unable to read legacy script '
'metadata, so cannot generate '
'scripts')
else:
try:
with zf.open(metadata_name) as bwf:
wf = wrapper(bwf)
commands = json.load(wf).get('commands')
except Exception:
logger.warning('Unable to read JSON metadata, so '
'cannot generate scripts')
if commands:
console_scripts = commands.get('wrap_console', {})
gui_scripts = commands.get('wrap_gui', {})
if console_scripts or gui_scripts:
script_dir = paths.get('scripts', '')
if not os.path.isdir(script_dir):
raise ValueError('Valid script path not '
'specified')
maker.target_dir = script_dir
for k, v in console_scripts.items():
script = '%s = %s' % (k, v)
filenames = maker.make(script)
fileop.set_executable_mode(filenames)
if gui_scripts:
options = {'gui': True }
for k, v in gui_scripts.items():
script = '%s = %s' % (k, v)
filenames = maker.make(script, options)
fileop.set_executable_mode(filenames)
p = os.path.join(libdir, info_dir)
dist = InstalledDistribution(p)
# Write SHARED
paths = dict(paths) # don't change passed in dict
del paths['purelib']
del paths['platlib']
paths['lib'] = libdir
p = dist.write_shared_locations(paths, dry_run)
if p:
outfiles.append(p)
# Write RECORD
dist.write_installed_files(outfiles, paths['prefix'],
dry_run)
return dist
except Exception: # pragma: no cover
logger.exception('installation failed.')
fileop.rollback()
raise
finally:
shutil.rmtree(workdir)
def _get_dylib_cache(self):
global cache
if cache is None:
# Use native string to avoid issues on 2.x: see Python #20140.
base = os.path.join(get_cache_base(), str('dylib-cache'),
sys.version[:3])
cache = Cache(base)
return cache
def _get_extensions(self):
pathname = os.path.join(self.dirname, self.filename)
name_ver = '%s-%s' % (self.name, self.version)
info_dir = '%s.dist-info' % name_ver
arcname = posixpath.join(info_dir, 'EXTENSIONS')
wrapper = codecs.getreader('utf-8')
result = []
with ZipFile(pathname, 'r') as zf:
try:
with zf.open(arcname) as bf:
wf = wrapper(bf)
extensions = json.load(wf)
cache = self._get_dylib_cache()
prefix = cache.prefix_to_dir(pathname)
cache_base = os.path.join(cache.base, prefix)
if not os.path.isdir(cache_base):
os.makedirs(cache_base)
for name, relpath in extensions.items():
dest = os.path.join(cache_base, convert_path(relpath))
if not os.path.exists(dest):
extract = True
else:
file_time = os.stat(dest).st_mtime
file_time = datetime.datetime.fromtimestamp(file_time)
info = zf.getinfo(relpath)
wheel_time = datetime.datetime(*info.date_time)
extract = wheel_time > file_time
if extract:
zf.extract(relpath, cache_base)
result.append((name, dest))
except KeyError:
pass
return result
def is_compatible(self):
"""
Determine if a wheel is compatible with the running system.
"""
return is_compatible(self)
def is_mountable(self):
"""
Determine if a wheel is asserted as mountable by its metadata.
"""
return True # for now - metadata details TBD
def mount(self, append=False):
pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
if not self.is_compatible():
msg = 'Wheel %s not compatible with this Python.' % pathname
raise DistlibException(msg)
if not self.is_mountable():
msg = 'Wheel %s is marked as not mountable.' % pathname
raise DistlibException(msg)
if pathname in sys.path:
logger.debug('%s already in path', pathname)
else:
if append:
sys.path.append(pathname)
else:
sys.path.insert(0, pathname)
extensions = self._get_extensions()
if extensions:
if _hook not in sys.meta_path:
sys.meta_path.append(_hook)
_hook.add(pathname, extensions)
def unmount(self):
pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
if pathname not in sys.path:
logger.debug('%s not in path', pathname)
else:
sys.path.remove(pathname)
if pathname in _hook.impure_wheels:
_hook.remove(pathname)
if not _hook.impure_wheels:
if _hook in sys.meta_path:
sys.meta_path.remove(_hook)
def verify(self):
pathname = os.path.join(self.dirname, self.filename)
name_ver = '%s-%s' % (self.name, self.version)
data_dir = '%s.data' % name_ver
info_dir = '%s.dist-info' % name_ver
metadata_name = posixpath.join(info_dir, METADATA_FILENAME)
wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
record_name = posixpath.join(info_dir, 'RECORD')
wrapper = codecs.getreader('utf-8')
with ZipFile(pathname, 'r') as zf:
with zf.open(wheel_metadata_name) as bwf:
wf = wrapper(bwf)
message = message_from_file(wf)
wv = message['Wheel-Version'].split('.', 1)
file_version = tuple([int(i) for i in wv])
# TODO version verification
records = {}
with zf.open(record_name) as bf:
with CSVReader(stream=bf) as reader:
for row in reader:
p = row[0]
records[p] = row
for zinfo in zf.infolist():
arcname = zinfo.filename
if isinstance(arcname, text_type):
u_arcname = arcname
else:
u_arcname = arcname.decode('utf-8')
if '..' in u_arcname:
raise DistlibException('invalid entry in '
'wheel: %r' % u_arcname)
# The signature file won't be in RECORD,
# and we don't currently don't do anything with it
if u_arcname.endswith('/RECORD.jws'):
continue
row = records[u_arcname]
if row[2] and str(zinfo.file_size) != row[2]:
raise DistlibException('size mismatch for '
'%s' % u_arcname)
if row[1]:
kind, value = row[1].split('=', 1)
with zf.open(arcname) as bf:
data = bf.read()
_, digest = self.get_hash(data, kind)
if digest != value:
raise DistlibException('digest mismatch for '
'%s' % arcname)
def update(self, modifier, dest_dir=None, **kwargs):
"""
Update the contents of a wheel in a generic way. The modifier should
be a callable which expects a dictionary argument: its keys are
archive-entry paths, and its values are absolute filesystem paths
where the contents the corresponding archive entries can be found. The
modifier is free to change the contents of the files pointed to, add
new entries and remove entries, before returning. This method will
extract the entire contents of the wheel to a temporary location, call
the modifier, and then use the passed (and possibly updated)
dictionary to write a new wheel. If ``dest_dir`` is specified, the new
wheel is written there -- otherwise, the original wheel is overwritten.
The modifier should return True if it updated the wheel, else False.
This method returns the same value the modifier returns.
"""
def get_version(path_map, info_dir):
version = path = None
key = '%s/%s' % (info_dir, METADATA_FILENAME)
if key not in path_map:
key = '%s/PKG-INFO' % info_dir
if key in path_map:
path = path_map[key]
version = Metadata(path=path).version
return version, path
def update_version(version, path):
updated = None
try:
v = NormalizedVersion(version)
i = version.find('-')
if i < 0:
updated = '%s-1' % version
else:
parts = [int(s) for s in version[i + 1:].split('.')]
parts[-1] += 1
updated = '%s-%s' % (version[:i],
'.'.join(str(i) for i in parts))
except UnsupportedVersionError:
logger.debug('Cannot update non-compliant (PEP-440) '
'version %r', version)
if updated:
md = Metadata(path=path)
md.version = updated
legacy = not path.endswith(METADATA_FILENAME)
md.write(path=path, legacy=legacy)
logger.debug('Version updated from %r to %r', version,
updated)
pathname = os.path.join(self.dirname, self.filename)
name_ver = '%s-%s' % (self.name, self.version)
info_dir = '%s.dist-info' % name_ver
record_name = posixpath.join(info_dir, 'RECORD')
with tempdir() as workdir:
with ZipFile(pathname, 'r') as zf:
path_map = {}
for zinfo in zf.infolist():
arcname = zinfo.filename
if isinstance(arcname, text_type):
u_arcname = arcname
else:
u_arcname = arcname.decode('utf-8')
if u_arcname == record_name:
continue
if '..' in u_arcname:
raise DistlibException('invalid entry in '
'wheel: %r' % u_arcname)
zf.extract(zinfo, workdir)
path = os.path.join(workdir, convert_path(u_arcname))
path_map[u_arcname] = path
# Remember the version.
original_version, _ = get_version(path_map, info_dir)
# Files extracted. Call the modifier.
modified = modifier(path_map, **kwargs)
if modified:
# Something changed - need to build a new wheel.
current_version, path = get_version(path_map, info_dir)
if current_version and (current_version == original_version):
# Add or update local version to signify changes.
update_version(current_version, path)
# Decide where the new wheel goes.
if dest_dir is None:
fd, newpath = tempfile.mkstemp(suffix='.whl',
prefix='wheel-update-',
dir=workdir)
os.close(fd)
else:
if not os.path.isdir(dest_dir):
raise DistlibException('Not a directory: %r' % dest_dir)
newpath = os.path.join(dest_dir, self.filename)
archive_paths = list(path_map.items())
distinfo = os.path.join(workdir, info_dir)
info = distinfo, info_dir
self.write_records(info, workdir, archive_paths)
self.build_zip(newpath, archive_paths)
if dest_dir is None:
shutil.copyfile(newpath, pathname)
return modified
def compatible_tags():
"""
Return (pyver, abi, arch) tuples compatible with this Python.
"""
versions = [VER_SUFFIX]
major = VER_SUFFIX[0]
for minor in range(sys.version_info[1] - 1, - 1, -1):
versions.append(''.join([major, str(minor)]))
abis = []
for suffix, _, _ in imp.get_suffixes():
if suffix.startswith('.abi'):
abis.append(suffix.split('.', 2)[1])
abis.sort()
if ABI != 'none':
abis.insert(0, ABI)
abis.append('none')
result = []
arches = [ARCH]
if sys.platform == 'darwin':
m = re.match('(\w+)_(\d+)_(\d+)_(\w+)$', ARCH)
if m:
name, major, minor, arch = m.groups()
minor = int(minor)
matches = [arch]
if arch in ('i386', 'ppc'):
matches.append('fat')
if arch in ('i386', 'ppc', 'x86_64'):
matches.append('fat3')
if arch in ('ppc64', 'x86_64'):
matches.append('fat64')
if arch in ('i386', 'x86_64'):
matches.append('intel')
if arch in ('i386', 'x86_64', 'intel', 'ppc', 'ppc64'):
matches.append('universal')
while minor >= 0:
for match in matches:
s = '%s_%s_%s_%s' % (name, major, minor, match)
if s != ARCH: # already there
arches.append(s)
minor -= 1
# Most specific - our Python version, ABI and arch
for abi in abis:
for arch in arches:
result.append((''.join((IMP_PREFIX, versions[0])), abi, arch))
# where no ABI / arch dependency, but IMP_PREFIX dependency
for i, version in enumerate(versions):
result.append((''.join((IMP_PREFIX, version)), 'none', 'any'))
if i == 0:
result.append((''.join((IMP_PREFIX, version[0])), 'none', 'any'))
# no IMP_PREFIX, ABI or arch dependency
for i, version in enumerate(versions):
result.append((''.join(('py', version)), 'none', 'any'))
if i == 0:
result.append((''.join(('py', version[0])), 'none', 'any'))
return set(result)
COMPATIBLE_TAGS = compatible_tags()
del compatible_tags
def is_compatible(wheel, tags=None):
if not isinstance(wheel, Wheel):
wheel = Wheel(wheel) # assume it's a filename
result = False
if tags is None:
tags = COMPATIBLE_TAGS
for ver, abi, arch in tags:
if ver in wheel.pyver and abi in wheel.abi and arch in wheel.arch:
result = True
break
return result
| {
"content_hash": "5f4872ed7d001e87017142e29328cabb",
"timestamp": "",
"source": "github",
"line_count": 952,
"max_line_length": 82,
"avg_line_length": 40.00525210084034,
"alnum_prop": 0.4843376657476697,
"repo_name": "cjerdonek/pip",
"id": "5a161409c1e151827a97440de9d6fe12975be52d",
"size": "38268",
"binary": false,
"copies": "6",
"ref": "refs/heads/develop",
"path": "pip/_vendor/distlib/wheel.py",
"mode": "33188",
"license": "mit",
"language": [
{
"name": "Python",
"bytes": "2081484"
},
{
"name": "Shell",
"bytes": "7929"
}
],
"symlink_target": ""
} |
Subsets and Splits