content
stringlengths 0
894k
| type
stringclasses 2
values |
|---|---|
#!/usr/bin/env python
import os
import sys
path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
sys.path.insert(0, path)
import django
def manage_16ormore():
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
def manage_15orless():
from django.core.management import execute_manager
try:
import settings # Assumed to be in the same directory.
except ImportError:
sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)
sys.exit(1)
execute_manager(settings)
if __name__ == "__main__":
if django.VERSION > (1, 6):
manage_16ormore()
else:
manage_15orless()
| python |
#Adding python objects to database
import sqlite3
from employee import Employee
#we are calling in the Employee class from the program which we made earlier, they must be in the same directory
conn=sqlite3.connect('sql.db')
c = conn.cursor()
#c.execute("""CREATE TABLE employees (
# first text,
# last text,
# pay integer
# )""")
emp_1 = Employee('John', 'Doe', 80000)
emp_2= Employee('Jane','Doe', 80000)
c.execute("INSERT INTO employees VALUES (?,?,?)", (emp_1.first,emp_1.last,emp_1.pay))
#here we are inserting the above instances into the database
c.execute("SELECT * FROM employees WHERE last=?", ('Grasshopper',))
#application of ? placeholder method
print(c.fetchall())
c.execute("SELECT * FROM employees WHERE last=:last", {'last':'Doe'})
#application of key placeholder method
print(c.fetchall())
conn.commit()
conn.close()
#executing this code will print the data which was inserted into the database
#check the output in the image file in this folder
| python |
from XTax import Tax
import io
import unittest
import unittest.mock
class Test_XTax(unittest.TestCase):
def test_TaxInitYear(self):
MyTax = Tax(2019,autoload=False)
self.assertEqual(MyTax.Year, 2019)
@unittest.mock.patch('sys.stdout', new_callable=io.StringIO)
def test_TaxInitLog(self,mock_stdout):
MyTax = Tax(2019,loglevel=1,autoload=False)
OutputList = mock_stdout.getvalue().split('\n')
self.assertEqual(len(OutputList), 4)
self.assertEqual(OutputList[0], "Beginning of Init")
self.assertEqual(OutputList[2], "End of Init")
if __name__ == '__main__':
unittest.main() | python |
import sys
try:
import threading
except ImportError:
import dummy_threading as threading
py32 = sys.version_info >= (3, 2)
py3k = sys.version_info >= (3, 0)
py2k = sys.version_info <= (3, 0)
if py3k:
string_types = str,
import itertools
itertools_filterfalse = itertools.filterfalse
if py32:
callable = callable
else:
def callable(fn):
return hasattr(fn, '__call__')
else:
string_types = basestring,
import itertools
itertools_filterfalse = itertools.ifilterfalse
callable = callable
| python |
import sys
import Heuristic
import RandomProblem
import SolveProblem
def main():
# auto random file if no input
if len(sys.argv) != 4:
RandomProblem.createRandomProblem('rand_in.txt', 8, 16)
pf = SolveProblem.ARA('rand_in.txt', 'rand_log.txt', 3,
Heuristic.EuclidDistance, 5)
pf.writeSolution('rand_out.txt')
else:
pf = SolveProblem.ARA(sys.argv[1], 'ARA_log.txt', 3,
Heuristic.EuclidDistance, int(sys.argv[3]))
pf.writeSolution(sys.argv[2])
if __name__ == '__main__':
main() | python |
"""Playbook Create"""
# standard library
import base64
import json
import logging
from typing import Any, Dict, Iterable, List, Optional, Union
# third-party
from pydantic import BaseModel
# first-party
from tcex.key_value_store import KeyValueApi, KeyValueRedis
from tcex.utils.utils import Utils
# get tcex logger
logger = logging.getLogger('tcex')
class PlaybookCreate:
"""Playbook Write ABC"""
def __init__(
self,
context: str,
key_value_store: Union[KeyValueApi, KeyValueRedis],
output_variables: list,
):
"""Initialize the class properties."""
self.context = context
self.key_value_store = key_value_store
self.output_variables = output_variables
# properties
self.log = logger
self.utils = Utils()
@staticmethod
def _check_iterable(value: str, validate: bool) -> None:
"""Raise an exception if value is not an Iterable.
Validation:
- not a dict (dicts are iterable)
- not a string (strings are iterable)
- is Iterable
"""
if validate is True and (isinstance(value, (dict, str)) or not isinstance(value, Iterable)):
raise RuntimeError('Invalid data provided for KeyValueArray.')
def _check_null(self, key: str, value: Any) -> bool:
"""Return True if key or value is null."""
invalid = False
if key is None:
self.log.warning('The provided key was None.')
invalid = True
if value is None:
self.log.warning(f'The provided value for key {key} was None.')
invalid = True
return invalid
def _check_requested(self, variable: str, when_requested: bool) -> None:
"""Return True if output variable was requested by downstream app."""
if when_requested is True and not self.is_requested(variable):
self.log.debug(f'Variable {variable} was NOT requested by downstream app.')
return False
return True
def _check_variable_type(self, variable: str, type_: str) -> bool:
"""Validate the correct type was passed to the method."""
if self.utils.get_playbook_variable_type(variable).lower() != type_.lower():
raise RuntimeError(
f'Invalid variable provided ({variable}), variable must be of type {type_}.'
)
@staticmethod
def _coerce_string_value(value: Union[bool, float, int, str]) -> str:
"""Return a string value from an bool or int."""
# coerce bool before int as python says a bool is an int
if isinstance(value, bool):
# coerce bool to str type
value = str(value).lower()
# coerce int to str type
if isinstance(value, (float, int)):
value = str(value)
return value
def _create_data(self, key: str, value: Any) -> None:
"""Write data to key value store."""
self.log.debug(f'writing variable {key.strip()}')
try:
return self.key_value_store.create(self.context, key.strip(), value)
except RuntimeError as e: # pragma: no cover
self.log.error(e)
return None
def _get_variable(self, key: str, variable_type: Optional[str] = None) -> str:
"""Return properly formatted variable.
A key can be provided as the variable key (e.g., app.output) or the
entire (e.g., #App:1234:app.output!String). The full variable is required
to create the record in the KV Store.
If a variable_type is provided an exact match will be found, however if no
variable type is known the first key match will be returned. Uniqueness of
keys is not guaranteed, but in more recent Apps it is the standard.
If no variable is found it means that the variable was not requested by the
any downstream Apps or could possible be formatted incorrectly.
"""
if not self.utils.is_playbook_variable(key):
# try to lookup the variable in the requested output variables.
for output_variable in self.output_variables:
variable_model = self.utils.get_playbook_variable_model(output_variable)
if variable_model.key == key and (
variable_type is None or variable_model.type == variable_type
):
# either an exact match, or first match
return output_variable
# not requested by downstream App or misconfigured
return None
# key was already a properly formatted variable
return key
@staticmethod
def _serialize_data(value: str) -> str:
"""Get the value from Redis if applicable."""
try:
return json.dumps(value)
except ValueError as e: # pragma: no cover
raise RuntimeError(f'Invalid data provided, failed to serialize value ({e}).')
@staticmethod
def _process_object_types(
value: Union[BaseModel, dict],
validate: Optional[bool] = True,
allow_none: Optional[bool] = False,
) -> Dict[str, Any]:
"""Process object types (e.g., KeyValue, TCEntity)."""
types = (BaseModel, dict)
if allow_none is True:
types = (BaseModel, dict, type(None))
if validate and not isinstance(value, types):
raise RuntimeError(f'Invalid type provided for object type ({type(value)}).')
if isinstance(value, BaseModel):
value = value.dict(exclude_unset=True)
return value
@staticmethod
def is_key_value(data: dict) -> bool:
"""Return True if provided data has proper structure for Key Value."""
if not isinstance(data, dict):
return False
return all(x in data for x in ['key', 'value'])
def is_requested(self, variable: str) -> bool:
"""Return True if provided variable was requested by downstream App."""
return variable in self.output_variables
@staticmethod
def is_tc_entity(data: dict) -> bool:
"""Return True if provided data has proper structure for TC Entity."""
if not isinstance(data, dict):
return False
return all(x in data for x in ['id', 'value', 'type'])
def any(
self,
key: str,
value: Union[
'BaseModel', bytes, dict, str, List['BaseModel'], List[bytes], List[dict], List[str]
],
validate: Optional[bool] = True,
variable_type: Optional[str] = None,
when_requested: Optional[bool] = True,
) -> Optional[Union[bytes, dict, list, str]]:
"""Write the value to the keystore for all types.
This is a quick helper method, for more advanced features
the individual write methods should be used (e.g., binary).
Args:
key: The variable to write to the DB (e.g., app.colors).
value: The data to write to the DB.
variable_type: The variable type being written. Only required if not unique.
Returns:
(str): Result string of DB write.
"""
if self._check_null(key, value) is True:
return None
# convert key to variable if required
variable = self._get_variable(key, variable_type)
if self._check_requested(variable, when_requested) is False:
return None
# get the type from the variable
variable_type = self.utils.get_playbook_variable_type(variable).lower()
# map type to create method
variable_type_map = {
'binary': self.binary,
'binaryarray': self.binary_array,
'keyvalue': self.key_value,
'keyvaluearray': self.key_value_array,
'string': self.string,
'stringarray': self.string_array,
'tcentity': self.tc_entity,
'tcentityarray': self.tc_entity_array,
# 'tcenhancedentity': self.tc_enhanced_entity_array,
}
return variable_type_map.get(variable_type, self.raw)(
variable, value, validate, when_requested
)
def binary(
self,
key: str,
value: bytes,
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
) -> Optional[int]:
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# convert key to variable if required
variable = self._get_variable(key, 'Binary')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'Binary')
# basic validation of value
if validate and not isinstance(value, bytes):
raise RuntimeError('Invalid data provided for Binary.')
# prepare value - playbook Binary fields are base64 encoded
value = base64.b64encode(value).decode('utf-8')
value = self._serialize_data(value)
return self._create_data(variable, value)
def binary_array(
self,
key: str,
value: List[bytes],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
):
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# validate array type provided
self._check_iterable(value, validate)
# convert key to variable if required
variable = self._get_variable(key, 'BinaryArray')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'BinaryArray')
# basic validation and prep of value
value_encoded = []
for v in value:
if v is not None:
if validate and not isinstance(v, bytes):
raise RuntimeError('Invalid data provided for Binary.')
v = base64.b64encode(v).decode('utf-8')
value_encoded.append(v)
value = value_encoded
value = self._serialize_data(value)
return self._create_data(variable, value)
def key_value(
self,
key: str,
value: Union[BaseModel, dict],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
) -> Optional[int]:
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# convert key to variable if required
variable = self._get_variable(key, 'KeyValue')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'KeyValue')
# basic validation and prep of value
value = self._process_object_types(value, validate)
if validate and not self.is_key_value(value):
raise RuntimeError('Invalid data provided for KeyValueArray.')
value = self._serialize_data(value)
return self._create_data(variable, value)
def key_value_array(
self,
key: str,
value: List[Union[BaseModel, dict]],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
):
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# validate array type provided
self._check_iterable(value, validate)
# convert key to variable if required
variable = self._get_variable(key, 'KeyValueArray')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'KeyValueArray')
# basic validation and prep of value
_value = []
for v in value:
v = self._process_object_types(v, validate, allow_none=True)
if validate and not self.is_key_value(v):
raise RuntimeError('Invalid data provided for KeyValueArray.')
_value.append(v)
value = _value
value = self._serialize_data(value)
return self._create_data(variable, value)
def string(
self,
key: str,
value: Union[bool, float, int, str],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
) -> Optional[int]:
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# convert key to variable if required
variable = self._get_variable(key, 'String')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'String')
# coerce string values
value = self._coerce_string_value(value)
# validation only needs to check str because value was coerced
if validate and not isinstance(value, str):
raise RuntimeError('Invalid data provided for String.')
value = self._serialize_data(value)
return self._create_data(variable, value)
def string_array(
self,
key: str,
value: List[Union[bool, float, int, str]],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
):
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# validate array type provided
self._check_iterable(value, validate)
# convert key to variable if required
variable = self._get_variable(key, 'StringArray')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'StringArray')
# basic validation and prep of value
value_coerced = []
for v in value:
# coerce string values
v = self._coerce_string_value(v)
# validation only needs to check str because value was coerced
if validate and not isinstance(v, (type(None), str)):
raise RuntimeError('Invalid data provided for StringArray.')
value_coerced.append(v)
value = value_coerced
value = self._serialize_data(value)
return self._create_data(variable, value)
# pylint: disable=unused-argument
def raw(
self,
key: str,
value: Union[bytes, str, int],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
) -> str:
"""Create method of CRUD operation for raw data.
Raw data can only be a byte, str or int. Other data
structures (dict, list, etc) must be serialized.
"""
if self._check_null(key, value):
return None
return self._create_data(key, value)
def tc_entity(
self,
key: str,
value: Union[BaseModel, dict],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
) -> Optional[int]:
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# convert key to variable if required
variable = self._get_variable(key, 'TCEntity')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'TCEntity')
# basic validation
value = self._process_object_types(value, validate)
if validate and not self.is_tc_entity(value):
raise RuntimeError('Invalid data provided for TcEntityArray.')
value = self._serialize_data(value)
return self._create_data(variable, value)
def tc_entity_array(
self,
key: str,
value: List[Union[BaseModel, dict]],
validate: Optional[bool] = True,
when_requested: Optional[bool] = True,
):
"""Create the value in Redis if applicable."""
if self._check_null(key, value) is True:
return None
# validate array type provided
self._check_iterable(value, validate)
# convert key to variable if required
variable = self._get_variable(key, 'TCEntityArray')
if self._check_requested(variable, when_requested) is False:
return None
# quick check to ensure an invalid type was not provided
self._check_variable_type(variable, 'TCEntityArray')
# basic validation and prep of value
_value = []
for v in value:
v = self._process_object_types(v, validate, allow_none=True)
if validate and not self.is_tc_entity(v):
raise RuntimeError('Invalid data provided for TcEntityArray.')
_value.append(v)
value = _value
value = self._serialize_data(value)
return self._create_data(variable, value)
def variable(
self,
key: str,
value: Union[
'BaseModel', bytes, dict, str, List['BaseModel'], List[bytes], List[dict], List[str]
],
variable_type: Optional[str] = None,
) -> str:
"""Alias for any method of CRUD operation for working with KeyValue DB.
This method will automatically check to see if provided variable was requested by
a downstream app and if so create the data in the KeyValue DB.
Args:
key: The variable to write to the DB (e.g., app.colors).
value: The data to write to the DB.
variable_type: The variable type being written. Only required if not unique.
Returns:
(str): Result string of DB write.
"""
if self._check_null(key, value) is True:
return None
# short-circuit the process, if there are no dowstream variables requested.
if not self.output_variables: # pragma: no cover
self.log.debug(f'Variable {key} was NOT requested by downstream app.')
return None
# key can be provided as the variable key (e.g., app.output) or
# the entire (e.g., #App:1234:app.output!String). we need the
# full variable to proceed.
variable = self._get_variable(key, variable_type)
if variable is None or variable not in self.output_variables:
self.log.debug(f'Variable {key} was NOT requested by downstream app.')
return None
# write the variable
return self.any(variable, value)
| python |
from moviepy.editor import *
clip = (VideoFileClip("../output_videos/project_video.mp4").subclip(10, 40).resize(0.3))
clip.write_gif("../output_videos/project_video.gif") | python |
# -*- coding: utf-8 -*-
"""
admin security exceptions module.
"""
from pyrin.core.exceptions import CoreException, CoreBusinessException
from pyrin.security.exceptions import AuthorizationFailedError
class AdminSecurityException(CoreException):
"""
admin security exception.
"""
pass
class AdminSecurityBusinessException(CoreBusinessException,
AdminSecurityException):
"""
admin security business exception.
"""
pass
class AdminAccessNotAllowedError(AuthorizationFailedError,
AdminSecurityBusinessException):
"""
admin access not allowed error.
"""
pass
| python |
# -*- coding: utf-8 -*-
#
# Copyright (c), 2018-2019, SISSA (International School for Advanced Studies).
# All rights reserved.
# This file is distributed under the terms of the MIT License.
# See the file 'LICENSE' in the root directory of the present
# distribution, or http://opensource.org/licenses/MIT.
#
# @author Davide Brunato <[email protected]>
#
"""
XPathToken and helper functions for XPath nodes. XPath error messages and node helper functions
are embedded in XPathToken class, in order to raise errors related to token instances.
In XPath there are 7 kinds of nodes:
element, attribute, text, namespace, processing-instruction, comment, document
Element-like objects are used for representing elements and comments, ElementTree-like objects
for documents. Generic tuples are used for representing attributes and named-tuples for namespaces.
"""
from __future__ import unicode_literals
import locale
import contextlib
from decimal import Decimal
from .compat import string_base_type, unicode_type
from .exceptions import xpath_error
from .namespaces import XQT_ERRORS_NAMESPACE
from .xpath_nodes import AttributeNode, TypedAttribute, TypedElement, \
is_etree_element, is_attribute_node, elem_iter_strings, is_text_node, \
is_namespace_node, is_comment_node, is_processing_instruction_node, \
is_element_node, is_document_node, is_xpath_node, is_schema_node
from .datatypes import UntypedAtomic, Timezone, DayTimeDuration, XSD_BUILTIN_TYPES
from .schema_proxy import AbstractSchemaProxy
from .tdop_parser import Token
from .xpath_context import XPathSchemaContext
def ordinal(n):
if n in {11, 12, 13}:
return '%dth' % n
least_significant_digit = n % 10
if least_significant_digit == 1:
return '%dst' % n
elif least_significant_digit == 2:
return '%dnd' % n
elif least_significant_digit == 3:
return '%drd' % n
else:
return '%dth' % n
class XPathToken(Token):
"""Base class for XPath tokens."""
comment = None # for XPath 2.0+ comments
xsd_type = None # fox XPath 2.0+ schema types labeling
def evaluate(self, context=None):
"""
Evaluate default method for XPath tokens.
:param context: The XPath dynamic context.
"""
return [x for x in self.select(context)]
def select(self, context=None):
"""
Select operator that generates XPath results.
:param context: The XPath dynamic context.
"""
item = self.evaluate(context)
if item is not None:
if isinstance(item, list):
for _item in item:
yield _item
else:
if context is not None:
context.item = item
yield item
def __str__(self):
symbol, label = self.symbol, self.label
if symbol == '$':
return '$%s variable reference' % (self[0].value if self else '')
elif symbol == ',':
return 'comma operator' if self.parser.version > '1.0' else 'comma symbol'
elif label == 'function':
return '%r function' % symbol
elif label == 'axis':
return '%r axis' % symbol
return super(XPathToken, self).__str__()
@property
def source(self):
symbol, label = self.symbol, self.label
if label == 'axis':
return '%s::%s' % (self.symbol, self[0].source)
elif label in ('function', 'constructor'):
return '%s(%s)' % (self.symbol, ', '.join(item.source for item in self))
elif symbol == ':':
return '%s:%s' % (self[0].source, self[1].source)
elif symbol == '(':
return '()' if not self else '(%s)' % self[0].source
elif symbol == '[':
return '%s[%s]' % (self[0].source, self[1].source)
elif symbol == ',':
return '%s, %s' % (self[0].source, self[1].source)
elif symbol == '$':
return '$%s' % self[0].source
elif symbol == '{':
return '{%s}%s' % (self[0].value, self[1].value)
elif symbol == 'instance':
return '%s instance of %s' % (self[0].source, ''.join(t.source for t in self[1:]))
elif symbol == 'treat':
return '%s treat as %s' % (self[0].source, ''.join(t.source for t in self[1:]))
return super(XPathToken, self).source
@property
def error_prefix(self):
for prefix, ns in self.parser.namespaces.items():
if ns == XQT_ERRORS_NAMESPACE:
return prefix
else:
return 'err'
###
# Helper methods
def get_argument(self, context, index=0, required=False, default_to_context=False,
default=None, cls=None):
"""
Get the argument value of a function of constructor token. A zero length sequence is
converted to a `None` value. If the function has no argument returns the context's
item if the dynamic context is not `None`.
:param context: the dynamic context.
:param index: an index for select the argument to be got, the first for default.
:param required: if set to `True` missing or empty sequence arguments are not allowed.
:param default_to_context: if set to `True` then the item of the dynamic context is \
returned when the argument is missing.
:param default: the default value returned in case the argument is an empty sequence. \
If not provided returns `None`.
:param cls: if a type is provided performs a type checking on item.
"""
try:
selector = self[index].select
except IndexError:
if default_to_context:
if context is None:
self.missing_context()
item = context.item if context.item is not None else context.root
elif required:
raise self.error('XPST0017', "Missing %s argument" % ordinal(index + 1))
else:
return
else:
item = None
for k, result in enumerate(selector(context)):
if k == 0:
item = result
elif not self.parser.compatibility_mode:
self.wrong_context_type("a sequence of more than one item is not allowed as argument")
else:
break
else:
if item is None:
if not required:
return default
ord_arg = ordinal(index + 1)
self.missing_sequence("A not empty sequence required for %s argument" % ord_arg)
# Type promotion checking (see "function conversion rules" in XPath 2.0 language definition)
if cls is not None and not isinstance(item, cls):
if self.parser.compatibility_mode:
if issubclass(cls, string_base_type):
return self.string_value(item)
elif issubclass(cls, float) or issubclass(float, cls):
return self.number_value(item)
if self.parser.version > '1.0':
value = self.data_value(item)
if isinstance(value, cls):
return value
elif isinstance(value, UntypedAtomic):
try:
if issubclass(cls, string_base_type):
return str(value)
else:
return cls(value)
except (TypeError, ValueError):
pass
code = 'XPTY0004' if self.label == 'function' else 'FORG0006'
message = "the %s argument %r is not an instance of %r"
raise self.error(code, message % (ordinal(index + 1), item, cls))
return item
def atomization(self, context=None):
"""
Helper method for value atomization of a sequence.
Ref: https://www.w3.org/TR/xpath20/#id-atomization
:param context: the XPath context.
"""
for item in self.select(context):
value = self.data_value(item)
if value is None:
raise self.error('FOTY0012', "argument node {!r} does not have a typed value".format(item))
else:
yield value
def get_atomized_operand(self, context=None):
"""
Get the atomized value for an XPath operator.
:param context: the XPath context.
:return: the atomized value of a single length sequence or `None` if the sequence is empty.
"""
selector = iter(self.atomization(context))
try:
value = next(selector)
except StopIteration:
return
else:
try:
next(selector)
except StopIteration:
if isinstance(value, UntypedAtomic):
value = str(value)
if isinstance(context, XPathSchemaContext):
return value
if self.xsd_type is not None and isinstance(value, string_base_type):
try:
value = self.xsd_type.decode(value)
except (TypeError, ValueError):
msg = "Type {!r} is not appropriate for the context"
self.wrong_context_type(msg.format(type(value)))
return value
else:
self.wrong_context_type("atomized operand is a sequence of length greater than one")
def get_comparison_data(self, context):
"""
Get comparison data couples for the general comparison of sequences. Different sequences
maybe generated with an XPath 2.0 parser, depending on compatibility mode setting.
Ref: https://www.w3.org/TR/xpath20/#id-general-comparisons
:param context: the XPath dynamic context.
:returns: a list of data couples.
"""
if context is None:
operand1 = [x for x in self[0].select()]
operand2 = [x for x in self[1].select()]
else:
operand1 = [x for x in self[0].select(context.copy())]
operand2 = [x for x in self[1].select(context.copy())]
if self.parser.compatibility_mode:
# Boolean comparison if one of the results is a single boolean value (1.)
try:
if isinstance(operand1[0], bool):
if len(operand1) == 1:
return [(operand1[0], self.boolean_value(operand2))]
if isinstance(operand2[0], bool):
if len(operand2) == 1:
return [(self.boolean_value(operand1), operand2[0])]
except IndexError:
return []
# Converts to float for lesser-greater operators (3.)
if self.symbol in ('<', '<=', '>', '>='):
return [
(float(self.data_value(value1)), float(self.data_value(value2)))
for value1 in operand1 for value2 in operand2
]
return [(self.data_value(value1), self.data_value(value2))
for value1 in operand1 for value2 in operand2]
def select_results(self, context):
"""
Generates formatted XPath results.
:param context: the XPath dynamic context.
"""
for result in self.select(context):
if isinstance(result, TypedElement):
yield result[0]
elif isinstance(result, AttributeNode):
yield result[1]
elif isinstance(result, TypedAttribute):
yield result[0][1] if hasattr(result[0][1], 'type') else result[1]
else:
yield result
def get_results(self, context):
"""
Returns formatted XPath results.
:param context: the XPath dynamic context.
:return: a list or a simple datatype when the result is a single simple type \
generated by a literal or function token.
"""
results = [x for x in self.select_results(context)]
if len(results) == 1:
res = results[0]
if isinstance(res, (bool, int, float, Decimal)):
return res
elif isinstance(res, tuple) or is_etree_element(res) or is_document_node(res):
return results
elif is_schema_node(res):
return results
elif self.symbol in ('text', 'node'):
return results
elif self.label in ('function', 'literal'):
return res
else:
return results
else:
return results
def get_operands(self, context, cls=None):
"""
Returns the operands for a binary operator. Float arguments are converted
to decimal if the other argument is a `Decimal` instance.
:param context: the XPath dynamic context.
:param cls: if a type is provided performs a type checking on item.
:return: a couple of values representing the operands. If any operand \
is not available returns a `(None, None)` couple.
"""
arg1 = self.get_argument(context, cls=cls)
if arg1 is None:
return None, None
arg2 = self.get_argument(context, index=1, cls=cls)
if arg2 is None:
return None, None
if isinstance(arg1, Decimal) and isinstance(arg2, float):
return arg1, Decimal(arg2)
elif isinstance(arg2, Decimal) and isinstance(arg1, float):
return Decimal(arg1), arg2
return arg1, arg2
def adjust_datetime(self, context, cls):
"""
XSD datetime adjust function helper.
:param context: the XPath dynamic context.
:param cls: the XSD datetime subclass to use.
:return: an empty list if there is only one argument that is the empty sequence \
or the adjusted XSD datetime instance.
"""
if len(self) == 1:
item = self.get_argument(context, cls=cls)
if item is None:
return []
timezone = getattr(context, 'timezone', None)
else:
item = self.get_argument(context=None, cls=cls) # don't use implicit timezone
timezone = self.get_argument(context, 1, cls=DayTimeDuration)
if timezone is not None:
timezone = Timezone.fromduration(timezone)
if item.tzinfo is not None and timezone is not None:
item += timezone.offset - item.tzinfo.offset
item.tzinfo = timezone
elif item.tzinfo is None:
if timezone is not None:
item.tzinfo = timezone
elif timezone is None:
item.tzinfo = None
return item
def match_xsd_type(self, schema_item, name):
"""
Match a token with a schema type, checking the matching between the provided schema
item and name. If there is a match and the token is already related with another
schema type an exception is raised.
:param schema_item: an XPath item related with a schema instance.
:param name: a QName in extended format for matching the item.
:returns: the matched XSD type or `None` if there isn't a match.
"""
if isinstance(schema_item, AttributeNode):
if not schema_item[1].is_matching(name):
return
try:
xsd_type = schema_item[1].type
except AttributeError:
try:
xsd_type = self.parser.schema.get_attribute(name).type
except AttributeError:
return
elif is_etree_element(schema_item):
if hasattr(schema_item, 'is_matching'):
if not schema_item.is_matching(name, self.parser.default_namespace):
return
elif schema_item.tag != name:
return
try:
xsd_type = schema_item.type
except AttributeError:
try:
xsd_type = self.parser.schema.get_element(name).type
except AttributeError:
return
else:
return
if self.xsd_type is None:
self.xsd_type = xsd_type
elif self.xsd_type is not xsd_type:
self.wrong_context_type("Multiple XSD type matching during static analysis")
return xsd_type
def get_typed_node(self, context, item):
"""
Returns a typed node if the token is bound to an XSD type.
:param context: the XPath dynamic context.
:param item: an untyped XPath attribute ot element.
"""
if isinstance(self.xsd_type, (type(None), AbstractSchemaProxy)):
return item
if isinstance(context, XPathSchemaContext):
primitive_type = self.parser.schema.get_primitive_type(self.xsd_type)
try:
value = XSD_BUILTIN_TYPES[primitive_type.local_name or 'anyType'].value
except KeyError:
value = XSD_BUILTIN_TYPES['anyType'].value
if isinstance(item, AttributeNode):
return TypedAttribute(item, value)
else:
return TypedElement(item, value)
else:
try:
if isinstance(item, AttributeNode):
return TypedAttribute(item, self.xsd_type.decode(item[1]))
elif self.xsd_type.is_simple() or self.xsd_type.has_simple_content():
return TypedElement(item, self.xsd_type.decode(item.text))
else:
return item
except (TypeError, ValueError):
msg = "Type {!r} does not match sequence type of {!r}"
self.wrong_sequence_type(msg.format(self.xsd_type, item))
@contextlib.contextmanager
def use_locale(self, collation):
"""A context manager for setting a specific collation for a code block."""
locale.setlocale(locale.LC_ALL, '')
default_locale = locale.getlocale()
try:
locale.setlocale(locale.LC_ALL, collation)
except locale.Error:
raise self.error('FOCH0002', 'Unsupported collation %r' % collation)
else:
yield
finally:
locale.setlocale(locale.LC_ALL, default_locale)
###
# XPath data accessors base functions
def data_value(self, obj):
"""
The typed value, as computed by fn:data() on each item. Returns an instance of
UntypedAtomic.
"""
if is_attribute_node(obj) or isinstance(obj, TypedElement):
obj = obj[1]
if obj is None:
return
elif not is_xpath_node(obj):
return obj
elif hasattr(obj, 'type'):
return self.schema_node_value(obj) # Schema context
return UntypedAtomic(self.string_value(obj))
def boolean_value(self, obj):
"""
The effective boolean value, as computed by fn:boolean().
"""
if isinstance(obj, list):
if not obj:
return False
elif isinstance(obj[0], tuple) or is_element_node(obj[0]):
return True
elif len(obj) == 1:
return bool(obj[0])
else:
raise self.error(
code='FORG0006',
message="Effective boolean value is not defined for a sequence of two or "
"more items not starting with an XPath node.",
)
elif isinstance(obj, tuple) or is_element_node(obj):
raise self.error('FORG0006', "Effective boolean value is not defined for {}.".format(obj))
return bool(obj)
def string_value(self, obj):
"""
The string value, as computed by fn:string().
"""
if obj is None:
return ''
elif is_element_node(obj):
return ''.join(elem_iter_strings(obj))
elif is_attribute_node(obj):
return unicode_type(obj[1])
elif is_text_node(obj):
return obj
elif is_document_node(obj):
return ''.join(e.text for e in obj.getroot().iter() if e.text is not None)
elif is_namespace_node(obj):
return obj[1]
elif is_comment_node(obj):
return obj.text
elif is_processing_instruction_node(obj):
return obj.text
elif is_schema_node(obj):
return str(self.schema_node_value(obj))
else:
return str(obj)
def number_value(self, obj):
"""
The numeric value, as computed by fn:number() on each item. Returns a float value.
"""
try:
return float(self.string_value(obj) if is_xpath_node(obj) else obj)
except (TypeError, ValueError):
return float('nan')
def schema_node_value(self, obj):
"""
Returns a sample typed value for the XSD schema node, valid in the value space
of the node. Used for schema-based dynamic evaluation of XPath expressions.
"""
try:
if obj.type.is_simple() or obj.type.has_simple_content():
# In case of schema element or attribute use a the sample value
# of the primitive type
primitive_type = self.parser.schema.get_primitive_type(obj.type)
return XSD_BUILTIN_TYPES[primitive_type.local_name].value
elif obj.type.local_name == 'anyType':
return XSD_BUILTIN_TYPES['anyType'].value
else:
return UntypedAtomic('')
except AttributeError:
raise self.wrong_type("the argument %r is not a node of an XSD schema" % obj)
###
# Error handling helpers
def error(self, code, message=None):
"""
Returns an XPath error instance related with a code. An XPath/XQuery/XSLT error code is an
alphanumeric token starting with four uppercase letters and ending with four digits.
:param code: the error code.
:param message: an optional custom additional message.
"""
return xpath_error(code, message, self, self.error_prefix)
# Shortcuts for XPath errors
def wrong_syntax(self, message=None):
if self.symbol == '::' and self.parser.token.symbol == '(name)':
self.missing_axis(message or "Axis '%s::' not found" % self.parser.token.value)
super(XPathToken, self).wrong_syntax(message)
def wrong_value(self, message=None):
raise self.error('FOCA0002', message)
def wrong_type(self, message=None):
raise self.error('FORG0006', message)
def missing_schema(self, message=None):
raise self.error('XPST0001', message)
def missing_context(self, message=None):
raise self.error('XPDY0002', message)
def wrong_context_type(self, message=None):
raise self.error('XPTY0004', message)
def missing_sequence(self, message=None):
raise self.error('XPST0005', message)
def missing_name(self, message=None):
raise self.error('XPST0008', message)
def missing_axis(self, message=None):
raise self.error('XPST0010', message)
def wrong_nargs(self, message=None):
raise self.error('XPST0017', message)
def wrong_step_result(self, message=None):
raise self.error('XPTY0018', message)
def wrong_intermediate_step_result(self, message=None):
raise self.error('XPTY0019', message)
def wrong_axis_argument(self, message=None):
raise self.error('XPTY0020', message)
def wrong_sequence_type(self, message=None):
raise self.error('XPDY0050', message)
def unknown_atomic_type(self, message=None):
raise self.error('XPST0051', message)
def wrong_target_type(self, message=None):
raise self.error('XPST0080', message)
def unknown_namespace(self, message=None):
raise self.error('XPST0081', message)
| python |
#! /usr/bin/env python3
# Conditions:
# * A child is playing with a ball on the nth floor of a tall building
# * The height of this floor, h, is known
# * He drops the ball out of the window. The ball bounces (for example),
# to two-thirds of its height (a bounce of 0.66).
# * His mother looks out of a window 1.5 meters from the ground.
# * How many times will the mother see the ball pass in front of her
# window (including when it's falling and bouncing?
#
# -- Three conditions must be met for a valid experiment:
# 1) Float parameter "h" in meters must be greater than 0
# 2) Float parameter "bounce" must be greater than 0 and less than 1
# 3) Float parameter "window" must be less than h.
# == If all three conditions above are fulfilled, return a positive
# integer, otherwise return -1.
#
# Note: The ball can only be seen if the height of the rebounding ball
# is strictly greater than the window parameter.
#
# Example:
# 1) h = 3, bounce = 0.66, window = 1.5, result is 3
# 2) h = 3, bounce = 1, window = 1.5, result is -1 (*)
# (*) Condition 2 not fulfilled.
#
def bouncing_ball(h, bounce, window):
if h <= 0 or not (0 < bounce < 1) or window >= h:
return -1
count = 0
while h > window:
count += 2 if count % 2 == 1 else 1
h *= bounce
return count
def test_bouncing_ball():
assert -1 == bouncing_ball(-1, 0, 0)
assert -1 == bouncing_ball(0, 0, 0)
assert -1 == bouncing_ball(1, -1, 0)
assert -1 == bouncing_ball(1, 0, 0)
assert -1 == bouncing_ball(1, 1, 0)
assert -1 == bouncing_ball(1, 2, 0)
assert -1 == bouncing_ball(1, .5, 1)
assert -1 == bouncing_ball(1, .5, 2)
assert 3 == bouncing_ball(3, 0.66, 1.5)
assert -1 == bouncing_ball(3, 1, 1.5)
if __name__ == '__main__':
test_bouncing_ball()
| python |
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: lbrynet/schema/proto/source.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf import symbol_database as _symbol_database
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
DESCRIPTOR = _descriptor.FileDescriptor(
name='lbrynet/schema/proto/source.proto',
package='',
syntax='proto2',
serialized_options=None,
serialized_pb=_b('\n!lbrynet/schema/proto/source.proto\"\xde\x01\n\x06Source\x12 \n\x07version\x18\x01 \x02(\x0e\x32\x0f.Source.Version\x12\'\n\nsourceType\x18\x02 \x02(\x0e\x32\x13.Source.SourceTypes\x12\x0e\n\x06source\x18\x03 \x02(\x0c\x12\x13\n\x0b\x63ontentType\x18\x04 \x02(\t\"*\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01\"8\n\x0bSourceTypes\x12\x17\n\x13UNKNOWN_SOURCE_TYPE\x10\x00\x12\x10\n\x0clbry_sd_hash\x10\x01')
)
_SOURCE_VERSION = _descriptor.EnumDescriptor(
name='Version',
full_name='Source.Version',
filename=None,
file=DESCRIPTOR,
values=[
_descriptor.EnumValueDescriptor(
name='UNKNOWN_VERSION', index=0, number=0,
serialized_options=None,
type=None),
_descriptor.EnumValueDescriptor(
name='_0_0_1', index=1, number=1,
serialized_options=None,
type=None),
],
containing_type=None,
serialized_options=None,
serialized_start=160,
serialized_end=202,
)
_sym_db.RegisterEnumDescriptor(_SOURCE_VERSION)
_SOURCE_SOURCETYPES = _descriptor.EnumDescriptor(
name='SourceTypes',
full_name='Source.SourceTypes',
filename=None,
file=DESCRIPTOR,
values=[
_descriptor.EnumValueDescriptor(
name='UNKNOWN_SOURCE_TYPE', index=0, number=0,
serialized_options=None,
type=None),
_descriptor.EnumValueDescriptor(
name='lbry_sd_hash', index=1, number=1,
serialized_options=None,
type=None),
],
containing_type=None,
serialized_options=None,
serialized_start=204,
serialized_end=260,
)
_sym_db.RegisterEnumDescriptor(_SOURCE_SOURCETYPES)
_SOURCE = _descriptor.Descriptor(
name='Source',
full_name='Source',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name='version', full_name='Source.version', index=0,
number=1, type=14, cpp_type=8, label=2,
has_default_value=False, default_value=0,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
name='sourceType', full_name='Source.sourceType', index=1,
number=2, type=14, cpp_type=8, label=2,
has_default_value=False, default_value=0,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
name='source', full_name='Source.source', index=2,
number=3, type=12, cpp_type=9, label=2,
has_default_value=False, default_value=_b(""),
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
name='contentType', full_name='Source.contentType', index=3,
number=4, type=9, cpp_type=9, label=2,
has_default_value=False, default_value=_b("").decode('utf-8'),
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
],
extensions=[
],
nested_types=[],
enum_types=[
_SOURCE_VERSION,
_SOURCE_SOURCETYPES,
],
serialized_options=None,
is_extendable=False,
syntax='proto2',
extension_ranges=[],
oneofs=[
],
serialized_start=38,
serialized_end=260,
)
_SOURCE.fields_by_name['version'].enum_type = _SOURCE_VERSION
_SOURCE.fields_by_name['sourceType'].enum_type = _SOURCE_SOURCETYPES
_SOURCE_VERSION.containing_type = _SOURCE
_SOURCE_SOURCETYPES.containing_type = _SOURCE
DESCRIPTOR.message_types_by_name['Source'] = _SOURCE
_sym_db.RegisterFileDescriptor(DESCRIPTOR)
Source = _reflection.GeneratedProtocolMessageType('Source', (_message.Message,), dict(
DESCRIPTOR = _SOURCE,
__module__ = 'lbrynet.schema.proto.source_pb2'
# @@protoc_insertion_point(class_scope:Source)
))
_sym_db.RegisterMessage(Source)
# @@protoc_insertion_point(module_scope)
| python |
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 9 23:58:12 2021
@author: AKayal
"""
from collections import namedtuple
from typing import List, NamedTuple
import datetime
from datetime import date
class personal_details(NamedTuple):
"""
Using the typing module, we can be even more explicit about our data structures.
https://realpython.com/python-namedtuple/
"""
ssn: str
first_name: str
last_name: str
gender: str
language: str
| python |
from whirlwind.store import create_task
from delfick_project.norms import sb, dictobj, Meta
from tornado.web import RequestHandler, HTTPError
from tornado import websocket
import binascii
import logging
import asyncio
import json
import uuid
log = logging.getLogger("whirlwind.request_handlers.base")
class Finished(Exception):
def __init__(self, status=500, **kwargs):
self.kwargs = kwargs
self.kwargs["status"] = status
def as_dict(self):
return self.kwargs
def reprer(o):
if type(o) is bytes:
return binascii.hexlify(o).decode()
return repr(o)
class MessageFromExc:
def __init__(self, *, log_exceptions=True, see_exception=None):
self.see_exception = see_exception
self.log_exceptions = log_exceptions
def __call__(self, exc_type, exc, tb):
if isinstance(exc, Finished):
return exc.kwargs
else:
return self.process(exc_type, exc, tb)
def process(self, exc_type, exc, tb):
if self.see_exception:
self.see_exception(exc_type, exc, tb)
if exc_type is asyncio.CancelledError:
return {
"status": 500,
"error": "Request was cancelled",
"error_code": "RequestCancelled",
}
else:
if self.see_exception is None and self.log_exceptions:
log.error(exc, exc_info=(exc_type, exc, tb))
return {
"status": 500,
"error": "Internal Server Error",
"error_code": "InternalServerError",
}
class AsyncCatcher(object):
def __init__(self, request, info, final=None):
self.info = info
self.final = final
self.request = request
async def __aenter__(self):
pass
async def __aexit__(self, exc_type, exc, tb):
if exc is None:
self.complete(self.info.get("result"), status=200)
return
msg = self.request.message_from_exc(exc_type, exc, tb)
self.complete(msg, status=500, exc_info=(exc_type, exc, tb))
# And don't reraise the exception
return True
def send_msg(self, msg, status=200, exc_info=None):
if self.request._finished and not hasattr(self.request, "ws_connection"):
if type(msg) is dict:
msg = json.dumps(msg, default=self.request.reprer, sort_keys=True, indent=" ")
self.request.hook("request_already_finished", msg)
return
if hasattr(msg, "exc_info") and exc_info is None:
exc_info = msg.exc_info
if self.final is None:
self.request.send_msg(msg, status, exc_info=exc_info)
else:
self.final(msg, exc_info=exc_info)
def complete(self, msg, status=sb.NotSpecified, exc_info=None):
if type(msg) is dict:
result = json.loads(json.dumps(msg, default=self.request.reprer, indent=" "))
else:
result = msg
self.send_msg(result, status=status, exc_info=exc_info)
class RequestsMixin:
"""
A mixin class you may use for your handler which provides some handy methods
for dealing with data
"""
_merged_options_formattable = True
def hook(self, func, *args, **kwargs):
if hasattr(self, func):
return getattr(self, func)(*args, **kwargs)
# def process_reply(self, msg, exc_info=None):
# """A hook that provides the msg sent as reply or progress"""
# pass
# def request_already_finished(self, msg):
# """Hook for when we would send a message to an already closed websocket"""
@property
def reprer(self):
if not hasattr(self, "_reprer"):
self._reprer = reprer
return self._reprer
@reprer.setter
def reprer(self, value):
self._reprer = value
@property
def message_from_exc(self):
if not hasattr(self, "_message_from_exc"):
self._message_from_exc = MessageFromExc(
see_exception=self.see_returned_exception,
log_exceptions=getattr(self, "log_exceptions", True),
)
return self._message_from_exc
def see_returned_exception(self, exc_typ, exc, tb):
if getattr(self, "log_exceptions", True):
log.error(exc, exc_info=(exc_typ, exc, tb))
@message_from_exc.setter
def message_from_exc(self, value):
self._message_from_exc = value
def async_catcher(self, info, final=None):
return AsyncCatcher(self, info, final=final)
def body_as_json(self, body=None):
"""
Return the body of the request as a json object
If there is a special ``__body__`` file in the request, we will consider this
to be the body instead of the request body
"""
if body is None:
if "__body__" in self.request.files:
body = self.request.files["__body__"][0]["body"].decode()
else:
body = self.request.body.decode()
try:
if type(body) is str:
body = json.loads(body)
except (TypeError, ValueError) as error:
self.log_json_error(body, error)
raise Finished(status=400, reason="Failed to load body as json", error=error)
return body
def log_json_error(self, body, error):
"""
Do any logging for errors parsing the request body as json
"""
log.error("Failed to load body as json\t%s", body)
def send_msg(self, msg, status=sb.NotSpecified, exc_info=None):
"""
This determines what content-type and exact body to write to the response
If ``msg`` has ``as_dict``, we call it.
If ``msg`` is a dictionary and has status, we use that as the status of
the request, otherwise we say it's a 200.
If there is ``html`` in ``msg``, we use that as the body of the request.
If ``msg`` is None, we close without a body.
* If ``msg`` is a ``dict`` or ``list``, we write it as a json object.
* If ``msg`` starts with ``<html>`` or ``<!DOCTYPE html>`` we treat it
as html content
* Otherwise we write ``msg`` as ``text/plain``
"""
if hasattr(msg, "exc_info") and exc_info is None:
exc_info = msg.exc_info
if hasattr(msg, "as_dict"):
msg = msg.as_dict()
self.hook("process_reply", msg, exc_info=exc_info)
if type(msg) is dict and "status" in msg:
status = msg["status"]
elif exc_info and exc_info[1]:
if hasattr(exc_info[1], "status"):
status = exc_info[1].status
else:
status = 500
if status is sb.NotSpecified:
status = 200
self.set_status(status)
if type(msg) is dict and "html" in msg:
msg = msg["html"]
if msg is None:
self.finish()
return
if type(msg) in (dict, list):
self.set_header("Content-Type", "application/json; charset=UTF-8")
self.write(json.dumps(msg, default=self.reprer, sort_keys=True, indent=" "))
elif msg.lstrip().startswith("<html>") or msg.lstrip().startswith("<!DOCTYPE html>"):
self.write(msg)
else:
self.set_header("Content-Type", "text/plain; charset=UTF-8")
self.write(msg)
self.finish()
class Simple(RequestsMixin, RequestHandler):
"""
Helper for using ``self.async_catcher`` from ``RequestsMixin`` for most HTTP verbs.
.. code-block:: python
class MyRequestHandler(Simple):
async def do_get():
return "<html><body><p>lol</p></body></html>"
Essentially you define ``async def do_<verb>(self)`` methods for each verb
you want to support.
This supports
* get
* put
* post
* patch
* delete
"""
log_exceptions = True
async def get(self, *args, **kwargs):
if not hasattr(self, "do_get"):
raise HTTPError(405)
info = {"result": None}
async with self.async_catcher(info):
info["result"] = await self.do_get(*args, **kwargs)
async def put(self, *args, **kwargs):
if not hasattr(self, "do_put"):
raise HTTPError(405)
info = {"result": None}
async with self.async_catcher(info):
info["result"] = await self.do_put(*args, **kwargs)
async def post(self, *args, **kwargs):
if not hasattr(self, "do_post"):
raise HTTPError(405)
info = {"result": None}
async with self.async_catcher(info):
info["result"] = await self.do_post(*args, **kwargs)
async def patch(self, *args, **kwargs):
if not hasattr(self, "do_patch"):
raise HTTPError(405)
info = {"result": None}
async with self.async_catcher(info):
info["result"] = await self.do_patch(*args, **kwargs)
async def delete(self, *args, **kwargs):
if not hasattr(self, "do_delete"):
raise HTTPError(405)
info = {"result": None}
async with self.async_catcher(info):
info["result"] = await self.do_delete(*args, **kwargs)
json_spec = sb.match_spec(
(bool, sb.any_spec()),
(int, sb.any_spec()),
(float, sb.any_spec()),
(str, sb.any_spec()),
(list, lambda: sb.listof(json_spec)),
(type(None), sb.any_spec()),
fallback=lambda: sb.dictof(sb.string_spec(), json_spec),
)
class SimpleWebSocketBase(RequestsMixin, websocket.WebSocketHandler):
"""
Used for websocket handlers
Implement ``process_message``
.. automethod:: whirlwind.request_handlers.base.SimpleWebSocketBase.process_message
This class takes in messages of the form ``{"path": <string>, "message_id": <string>, "body": <dictionary}``
It will respond with messages of the form ``{"reply": <reply>, "message_id": <message_id>}``
It treats path of ``__tick__`` as special and respond with ``{"reply": {"ok": "thankyou"}, "message_id": "__tick__"}``
It relies on the client side closing the connection when it's finished.
"""
log_exceptions = True
def initialize(self, final_future, server_time, wsconnections):
self.server_time = server_time
self.final_future = final_future
self.wsconnections = wsconnections
class WSMessage(dictobj.Spec):
path = dictobj.Field(sb.string_spec, wrapper=sb.required)
message_id = dictobj.Field(
sb.or_spec(sb.string_spec(), sb.tupleof(sb.string_spec())), wrapper=sb.required
)
body = dictobj.Field(json_spec, wrapper=sb.required)
message_spec = WSMessage.FieldSpec()
class Closing(object):
pass
def open(self):
self.key = str(uuid.uuid1())
self.connection_future = asyncio.Future()
if self.final_future.done():
self.connection_future.cancel()
return
canceller = lambda res: self.connection_future.cancel()
self.final_future.add_done_callback(canceller)
self.connection_future.add_done_callback(
lambda res: self.final_future.remove_done_callback(canceller)
)
if self.server_time is not None:
self.reply(self.server_time, message_id="__server_time__")
self.hook("websocket_opened")
def reply(self, msg, message_id=None, exc_info=None):
if msg is None:
msg = {"done": True}
# I bypass tornado converting the dictionary so that non jsonable things can be repr'd
if hasattr(msg, "as_dict"):
msg = msg.as_dict()
reply = {"reply": msg, "message_id": message_id}
reply = json.dumps(reply, default=self.reprer).replace("</", "<\\/")
if message_id not in ("__tick__", "__server_time__"):
self.hook("process_reply", msg, exc_info=exc_info)
if self.ws_connection:
self.write_message(reply)
def on_message(self, message):
self.hook("websocket_message", message)
try:
parsed = json.loads(message)
except (TypeError, ValueError) as error:
self.reply({"error": "Message wasn't valid json\t{0}".format(str(error))})
return
if type(parsed) is dict and "path" in parsed and parsed["path"] == "__tick__":
parsed["message_id"] = "__tick__"
parsed["body"] = "__tick__"
try:
msg = self.message_spec.normalise(Meta.empty(), parsed)
except Exception as error:
self.hook("websocket_invalid_message", error, parsed)
if hasattr(error, "as_dict"):
error = error.as_dict()
else:
error = str(error)
self.reply({"error_code": "InvalidMessage", "error": error})
else:
path = msg.path
body = msg.body
message_id = msg.message_id
message_key = str(uuid.uuid4())
if path == "__tick__":
self.reply({"ok": "thankyou"}, message_id=message_id)
return
def on_processed(final, exc_info=None):
if final is self.Closing:
self.reply({"closing": "goodbye"}, message_id=message_id)
self.close()
else:
self.reply(final, message_id=message_id, exc_info=exc_info)
try:
self.message_done(msg, final, message_key, exc_info=exc_info)
except Exception as error:
self.handle_message_done_error(error, msg, final, message_key, exc_info)
async def doit():
info = {}
def progress_cb(progress, **kwargs):
for m in self.transform_progress(msg, progress, **kwargs):
self.reply(m, message_id=message_id)
async with self.async_catcher(info, on_processed):
result = await self.process_message(
path, body, message_id, message_key, progress_cb
)
if isinstance(result, asyncio.Future) or hasattr(result, "__await__"):
result = await result
info["result"] = result
def done(res):
if message_key in self.wsconnections:
del self.wsconnections[message_key]
if not res.cancelled():
self.handle_request_done_exception(res.exception())
t = create_task(doit(), name=f"<process_command: {body}>")
t.add_done_callback(done)
self.wsconnections[message_key] = t
def message_done(self, request, final, message_key, exc_info=None):
"""
Hook for when we have finished processing a request
By default nothing is done.
request
The original request
final
The last response to be sent back.
message_key
The uuid the server generated for this request
exc_info
The (exc_type, exc, traceback) for any exception that stopped the processing of the request
"""
def handle_message_done_error(self, error, msg, final, message_key, exc_info):
"""
Hook for when message_done raised an exception
By default we ``log.exception(error)``
error
The exception that was raised
request
The original request
final
The last response to be sent back.
message_key
The uuid the server generated for this request
exc_info
The (exc_type, exc, traceback) for any exception that stopped the processing of the request
before message_done had been called
"""
log.exception(error)
def handle_request_done_exception(self, error):
"""Hook that takes in an exception from the entire request"""
if error and self.log_exceptions:
log.exception(error, exc_info=(type(error), error, error.__traceback__))
def transform_progress(self, body, progress, **kwargs):
"""
Hook for transforming progress messages. This must be a generator that yields 0 or more messages
So when the ``progress_cb`` is called like ``progress_cb("some message", arg=1)`` we will do:
.. code-block:: python
for m in self.transform_progress(<request>, "some message", arg=1):
# write ``{"reply": m, "message_id": <message_id>}``
where ``<request>`` is the entire message that started this stream.
By default kwargs are ignored and we just yield ``{"progress": progress}`` once
"""
yield {"progress": progress}
async def process_message(self, path, body, message_id, message_key, progress_cb):
"""
Return the response to be sent back when we get a message from the conn.
path
The uri specified in the message
body
The body specified in the message
message_id
The unique message_id for this stream of requests as supplied in the request
message_key
A unique id for this stream created by the server
progress_cb
A callback that will send a message of the form ``{"progress": <progress>, "message_id": <message_id}``
where ``<progress>`` is the argument passed into the callback
"""
raise NotImplementedError
def on_close(self):
"""Hook for when a websocket connection closes"""
self.connection_future.cancel()
| python |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon May 22 14:33:38 2017
@author: paul
"""
from weatherTLKT import Weather
typ='ens'
for ss in range(1,9):
if typ=='solo':
mydate='20171127'
website='http://nomads.ncep.noaa.gov:9090/dods'
model='gfs'
resolution='0p25'
url=website+'/'+model+'_'+resolution+'/'+model+mydate+'/'+model+'_'+resolution+'_00z'
pathToSaveObj='../data/'+ model+mydate+'_'+resolution
else :
mydate='20171127'
website='http://nomads.ncep.noaa.gov:9090/dods'
model='gens'
resolution='0p25'
num_scenario='0'+str(ss)
url=website+'/'+model+'/'+model+mydate+'/'+'gep'+num_scenario+'_00z'
pathToSaveObj='../data/'+ model+mydate+'_'+num_scenario
latBound=[43,50]
lonBound=[-10+360, 360]
Weather.download(url,pathToSaveObj,latBound=latBound,lonBound=lonBound,timeSteps=[0,85],ens=True)
| python |
from django.views.generic import TemplateView, ListView, DetailView
from . import models
class DashboardView(TemplateView):
template_name = "organizations/dashboard.html"
class OrganizationDetailView(DetailView):
template_name = "organizations/organization_details.html"
model = models.Organization
class OrganizationListView(ListView):
template_name = "organizations/organization_list.html"
model = models.Organization
class OrganizationalUnitDetailView(DetailView):
template_name = "organizations/organizational_unit_details.html"
model = models.OrganizationalUnit
class OrganizationalUnitListView(ListView):
template_name = "organizations/organizational_unit_list.html"
model = models.OrganizationalUnit
| python |
import csv
import xlsxwriter
import datetime
# Sequence Analysis Data Object
# Holds all items needed for analysis
class SeqData:
its_dict = None
seq_config = None
num_threads = None
output_format = None
def __init__(self, its_dict, seq_config, num_threads, output_format):
self.num_threads = num_threads
self.its_dict = its_dict
self.seq_config = seq_config
self.output_format = output_format
# Sequence Analysis Run Object
# Put into queue; used in Perform()
class SeqRun:
p_id = None
path = None
def __init__(self, p_id, path):
self.p_id = p_id
self.path = path
# Output Object
# sent to output functions
class OutData:
batch_store = None
seq_config = None
results = None
def __init__(self, batch_store, seq_config, results):
self.batch_store = batch_store
self.seq_config = seq_config
self.results = results
# Output to CSV format
def output_csv(out_data):
"This method outputs the analysis results to a .csv file"
# output code
print("Output in .csv")
# create + write csv file
out_file = out_data.seq_config['outputDirPath'] +'//'+ "LC2-"+out_data.batch_store+"-"+out_data.seq_config['seqType']+"-"+str(out_data.seq_config['PauseDur']).replace('.','p')+"-"+str(out_data.seq_config['roundingEnabled'])+"-"+datetime.datetime.now().strftime('%m%d%y-%H%M')+".csv"
with open( out_file, 'wb') as f:#open csv file to be written in
csv_writer = csv.writer(f, delimiter = ',')
for line in out_data.results:#loop to write rows to csv file
line = line.split(',')
csv_writer.writerow(line)
# Output to TXT format
def ouput_txt(out_data):
"This method outputs the analysis results to a .txt file"
# output code
print("Output in .txt")
# create + write txt file
out_file = out_data.seq_config['outputDirPath'] +'//'+ "LC2-"+out_data.batch_store+"-"+out_data.seq_config['seqType']+"-"+str(out_data.seq_config['PauseDur']).replace('.','p')+"-"+str(out_data.seq_config['roundingEnabled'])+"-"+datetime.datetime.now().strftime('%m%d%y-%H%M')+".txt"
with open(out_file,'w') as f:
for line in out_data.results:
f.writelines(line+"\n")
# Output to Excel format
def output_xlsx(out_data):
"This method outputs the analysis results to a .xlsx file"
print("Output in .xlsx")
# create workbook & add sheet
out_file = out_data.seq_config['outputDirPath'] +'//'+ "LC2-"+out_data.batch_store+"-"+out_data.seq_config['seqType']+"-"+str(out_data.seq_config['PauseDur']).replace('.','p')+"-"+str(out_data.seq_config['roundingEnabled'])+"-"+datetime.datetime.now().strftime('%m%d%y-%H%M')+".xlsx"
workbook = xlsxwriter.Workbook(out_file)
worksheet = workbook.add_worksheet()
# start from first cell
row = 0
# insert into worksheet
for line in out_data.results:
col = 0
for cell in str(line).split(","):
worksheet.write(row, col, cell)
col += 1
row += 1
# close file
workbook.close() | python |
import pandas as pd
from strategy.astrategy import AStrategy
from processor.processor import Processor as p
from datetime import timedelta
import pytz
from tqdm import tqdm
from time import sleep
pd.options.mode.chained_assignment = None
class ProgressReport(AStrategy):
def __init__(self,start_date,end_date,modeling_params={},trading_params={"value":True,"requirement":5}):
super().__init__(f"progress_report",
start_date,
end_date,
{"market":{}},modeling_params=modeling_params,trading_params=trading_params)
self.exit_days = 45
self.last_call_day = 90
@classmethod
def required_params(self):
required = {"timeframe":"quarterly"
,"requirement":5}
return required
def create_sim(self):
if self.simmed:
self.db.connect()
sim = self.db.retrieve("sim")
self.db.disconnect()
else:
start_year = self.start_date.year
end_year = self.end_date.year
market = self.subscriptions["market"]["db"]
market.connect()
self.db.connect()
tickers = market.retrieve_tickers("prices")
sim = []
for ticker in tqdm(tickers["ticker"].unique(),desc=f"{self.name}_sim"):
prices = market.retrieve_ticker_prices("prices",ticker)
prices = p.column_date_processing(prices)
prices["year"] = [x.year for x in prices["date"]]
prices["quarter"] = [x.quarter for x in prices["date"]]
for year in range(start_year,end_year):
for quarter in range(1,5):
try:
ticker_data = prices[(prices["year"]==year) & (prices["quarter"]==quarter)].sort_values("date")
sp = ticker_data.iloc[0]["adjclose"].item()
ticker_data["quarter_start"] = sp
ticker_data["delta"] = (ticker_data["adjclose"] - sp) / sp
ticker_data = ticker_data[["date","adjclose","delta","ticker"]]
for param in self.modeling_params:
ticker_data[param]=self.modeling_params[param]
sim.append(ticker_data)
self.db.store("sim",ticker_data)
except Exception as e:
continue
sim = pd.concat(sim)
self.db.disconnect()
market.disconnect()
self.simmed = True
return sim
def create_rec(self,date):
self.db.connect()
rec = self.db.query("rec",self.modeling_params)
self.db.disconnect()
if rec.index.size > 1:
rec = p.column_date_processing(rec)
small_rec = rec[rec["date"]>=date]
if small_rec.index.size > 1:
return small_rec
else:
year = date.year
month = date.month
quarter = int((month-1)/3) + 1
market = self.subscriptions["market"]["db"]
market.connect()
self.db.connect()
tickers = market.retrieve_tickers("prices")
sim = []
for ticker in tqdm(tickers["ticker"].unique(),desc=f"{self.name}_sim"):
prices = market.retrieve_ticker_prices("prices",ticker)
prices = p.column_date_processing(prices)
prices["year"] = [x.year for x in prices["date"]]
prices["quarter"] = [x.quarter for x in prices["date"]]
try:
ticker_data = prices[(prices["year"]==year) & (prices["quarter"]==quarter)].sort_values("date")
sp = ticker_data.iloc[0]["adjclose"].item()
ticker_data["quarter_start"] = sp
ticker_data["delta"] = (ticker_data["adjclose"] - sp) / sp
ticker_data = ticker_data[["date","adjclose","delta","ticker"]]
for param in self.modeling_params:
ticker_data[param]=self.modeling_params[param]
sim.append(ticker_data.tail(1))
self.db.store("rec",ticker_data.tail(1))
except Exception as e:
continue
recs = pd.concat(sim)
self.db.disconnect()
market.disconnect()
return recs | python |
from functools import reduce
from operator import mul
import numpy as onp
from numpy.testing import assert_allclose
import pytest
import scipy.stats as osp_stats
import jax
from jax import grad, lax, random
import jax.numpy as np
from jax.scipy.special import logit
import numpyro.contrib.distributions as dist
from numpyro.contrib.distributions import jax_multivariate, validation_enabled
from numpyro.distributions import constraints
def idfn(param):
if isinstance(param, (osp_stats._distn_infrastructure.rv_generic,
osp_stats._multivariate.multi_rv_generic)):
return param.name
elif isinstance(param, constraints.Constraint):
return param.__class__.__name__
return repr(param)
@pytest.mark.parametrize('jax_dist', [
dist.beta,
dist.cauchy,
dist.expon,
dist.gamma,
dist.halfcauchy,
dist.halfnorm,
dist.lognorm,
dist.pareto,
dist.trunccauchy,
dist.truncnorm,
dist.norm,
dist.t,
dist.uniform,
], ids=idfn)
@pytest.mark.parametrize('loc, scale', [
(1, 1),
(1., np.array([1., 2.])),
])
@pytest.mark.parametrize('prepend_shape', [
None,
(),
(2,),
(2, 3),
])
def test_continuous_shape(jax_dist, loc, scale, prepend_shape):
rng = random.PRNGKey(0)
args = [i + 1 for i in range(jax_dist.numargs)]
expected_shape = lax.broadcast_shapes(*[np.shape(loc), np.shape(scale)])
samples = jax_dist.rvs(*args, loc=loc, scale=scale, random_state=rng)
assert isinstance(samples, jax.interpreters.xla.DeviceArray)
assert np.shape(samples) == expected_shape
assert np.shape(jax_dist(*args, loc=loc, scale=scale).rvs(random_state=rng)) == expected_shape
if prepend_shape is not None:
expected_shape = prepend_shape + lax.broadcast_shapes(*[np.shape(loc), np.shape(scale)])
assert np.shape(jax_dist.rvs(*args, loc=loc, scale=scale,
size=expected_shape, random_state=rng)) == expected_shape
assert np.shape(jax_dist(*args, loc=loc, scale=scale)
.rvs(random_state=rng, size=expected_shape)) == expected_shape
@pytest.mark.parametrize('jax_dist, dist_args, sample', [
(dist.beta, (-1, 1), -1),
(dist.beta, (2, np.array([1., -3])), np.array([1., -2])),
(dist.cauchy, (), np.inf),
(dist.cauchy, (), np.array([1., np.nan])),
(dist.expon, (), -1),
(dist.expon, (), np.array([1., -2])),
(dist.gamma, (-1,), -1),
(dist.gamma, (np.array([-2., 3]),), np.array([1., -2])),
(dist.halfcauchy, (), -1),
(dist.halfcauchy, (), np.array([1., -2])),
(dist.halfnorm, (), -1),
(dist.halfnorm, (), np.array([1., -2])),
(dist.lognorm, (-1,), -1),
(dist.lognorm, (np.array([-2., 3]),), np.array([1., -2])),
(dist.norm, (), np.inf),
(dist.norm, (), np.array([1., np.nan])),
(dist.pareto, (-1,), -1),
(dist.pareto, (np.array([-2., 3]),), np.array([1., -2])),
(dist.t, (-1,), np.inf),
(dist.t, (np.array([-2., 3]),), np.array([1., np.nan])),
(dist.trunccauchy, (), -1),
(dist.trunccauchy, (), np.array([1., -2])),
(dist.truncnorm, (), -1),
(dist.truncnorm, (), np.array([1., -2])),
(dist.uniform, (), -1),
(dist.uniform, (), np.array([0.5, -2])),
], ids=idfn)
def test_continuous_validate_args(jax_dist, dist_args, sample):
valid_args = [i + 1 for i in range(jax_dist.numargs)]
with validation_enabled():
if dist_args:
with pytest.raises(ValueError, match='Invalid parameters'):
jax_dist(*dist_args)
with pytest.raises(ValueError, match='Invalid scale parameter'):
jax_dist(*valid_args, scale=-1)
frozen_dist = jax_dist(*valid_args)
with pytest.raises(ValueError, match='Invalid values'):
frozen_dist.logpdf(sample)
@pytest.mark.parametrize('jax_dist, dist_args', [
(dist.categorical, (np.array([0.1, 0.9]),)),
(dist.categorical, (np.array([[0.1, 0.9], [0.2, 0.8]]),)),
(dist.dirichlet, (np.ones(3),)),
(dist.dirichlet, (np.ones((2, 3)),)),
(dist.multinomial, (10, np.array([0.1, 0.9]),)),
(dist.multinomial, (10, np.array([[0.1, 0.9], [0.2, 0.8]]),)),
], ids=idfn)
@pytest.mark.parametrize('prepend_shape', [
None,
(),
(2,),
(2, 3),
])
def test_multivariate_shape(jax_dist, dist_args, prepend_shape):
rng = random.PRNGKey(0)
expected_shape = jax_dist._batch_shape(*dist_args) + jax_dist._event_shape(*dist_args)
samples = jax_dist.rvs(*dist_args, random_state=rng)
assert isinstance(samples, jax.interpreters.xla.DeviceArray)
assert np.shape(samples) == expected_shape
assert np.shape(jax_dist(*dist_args).rvs(random_state=rng)) == expected_shape
if prepend_shape is not None:
size = prepend_shape + jax_dist._batch_shape(*dist_args)
expected_shape = size + jax_dist._event_shape(*dist_args)
samples = jax_dist.rvs(*dist_args, size=size, random_state=rng)
assert np.shape(samples) == expected_shape
samples = jax_dist(*dist_args).rvs(random_state=rng, size=size)
assert np.shape(samples) == expected_shape
@pytest.mark.parametrize('jax_dist, valid_args, invalid_args, invalid_sample', [
(dist.categorical, (np.array([0.1, 0.9]),), (np.array([0.1, 0.8]),), np.array([1, 4])),
(dist.dirichlet, (np.ones(3),), (np.array([-1., 2., 3.]),), np.array([0.1, 0.7, 0.1])),
(dist.multinomial, (10, np.array([0.1, 0.9]),), (10, np.array([0.2, 0.9]),), np.array([-1, 9])),
], ids=idfn)
def test_multivariate_validate_args(jax_dist, valid_args, invalid_args, invalid_sample):
with validation_enabled():
with pytest.raises(ValueError, match='Invalid parameters'):
jax_dist(*invalid_args)
frozen_dist = jax_dist(*valid_args)
with pytest.raises(ValueError, match='Invalid values'):
frozen_dist.logpmf(invalid_sample)
@pytest.mark.parametrize('jax_dist, dist_args', [
(dist.bernoulli, (0.1,)),
(dist.bernoulli, (np.array([0.3, 0.5]),)),
(dist.binom, (10, 0.4)),
(dist.binom, (np.array([10]), np.array([0.4, 0.3]))),
(dist.poisson, (1.,)),
(dist.poisson, (np.array([1., 4., 10.]),)),
], ids=idfn)
@pytest.mark.parametrize('prepend_shape', [
None,
(),
(2,),
(2, 3),
])
def test_discrete_shape(jax_dist, dist_args, prepend_shape):
rng = random.PRNGKey(0)
sp_dist = getattr(osp_stats, jax_dist.name)
expected_shape = np.shape(sp_dist.rvs(*dist_args))
samples = jax_dist.rvs(*dist_args, random_state=rng)
assert isinstance(samples, jax.interpreters.xla.DeviceArray)
assert np.shape(samples) == expected_shape
if prepend_shape is not None:
shape = prepend_shape + lax.broadcast_shapes(*[np.shape(arg) for arg in dist_args])
expected_shape = np.shape(sp_dist.rvs(*dist_args, size=shape))
assert np.shape(jax_dist.rvs(*dist_args, size=shape, random_state=rng)) == expected_shape
@pytest.mark.parametrize('jax_dist, valid_args, invalid_args, invalid_sample', [
(dist.bernoulli, (0.8,), (np.nan,), 2),
(dist.binom, (10, 0.8), (-10, 0.8), -10),
(dist.binom, (10, 0.8), (10, 1.1), -1),
(dist.poisson, (4.,), (-1.,), -1),
], ids=idfn)
def test_discrete_validate_args(jax_dist, valid_args, invalid_args, invalid_sample):
with validation_enabled():
with pytest.raises(ValueError, match='Invalid parameters'):
jax_dist(*invalid_args)
frozen_dist = jax_dist(*valid_args)
with pytest.raises(ValueError, match='Invalid values'):
frozen_dist.logpmf(invalid_sample)
@pytest.mark.parametrize('jax_dist', [
dist.beta,
dist.cauchy,
dist.expon,
dist.gamma,
dist.halfcauchy,
dist.halfnorm,
dist.lognorm,
dist.norm,
dist.pareto,
dist.t,
dist.trunccauchy,
dist.truncnorm,
dist.uniform,
], ids=idfn)
@pytest.mark.parametrize('loc, scale', [
(1., 1.),
(1., np.array([1., 2.])),
])
def test_sample_gradient(jax_dist, loc, scale):
rng = random.PRNGKey(0)
args = [i + 1 for i in range(jax_dist.numargs)]
expected_shape = lax.broadcast_shapes(*[np.shape(loc), np.shape(scale)])
def fn(args, loc, scale):
return jax_dist.rvs(*args, loc=loc, scale=scale, random_state=rng).sum()
# FIXME: find a proper test for gradients of arg parameters
assert len(grad(fn)(args, loc, scale)) == jax_dist.numargs
assert_allclose(grad(fn, 1)(args, loc, scale),
loc * reduce(mul, expected_shape[:len(expected_shape) - np.ndim(loc)], 1.))
assert_allclose(grad(fn, 2)(args, loc, scale),
jax_dist.rvs(*args, size=expected_shape, random_state=rng))
@pytest.mark.parametrize('jax_dist, dist_args', [
(dist.dirichlet, (np.ones(3),)),
(dist.dirichlet, (np.ones((2, 3)),)),
], ids=idfn)
def test_mvsample_gradient(jax_dist, dist_args):
rng = random.PRNGKey(0)
def fn(args):
return jax_dist.rvs(*args, random_state=rng).sum()
# FIXME: find a proper test for gradients of arg parameters
assert len(grad(fn)(dist_args)) == jax_dist.numargs
@pytest.mark.parametrize('jax_dist', [
dist.beta,
dist.cauchy,
dist.expon,
dist.gamma,
dist.halfcauchy,
dist.halfnorm,
dist.lognorm,
dist.norm,
dist.pareto,
dist.t,
dist.trunccauchy,
dist.truncnorm,
dist.uniform,
], ids=idfn)
@pytest.mark.parametrize('loc_scale', [
(),
(1,),
(1, 1),
(1., np.array([1., 2.])),
])
def test_continuous_logpdf(jax_dist, loc_scale):
rng = random.PRNGKey(0)
args = [i + 1 for i in range(jax_dist.numargs)] + list(loc_scale)
samples = jax_dist.rvs(*args, random_state=rng)
if jax_dist is dist.trunccauchy:
sp_dist = osp_stats.cauchy
assert_allclose(jax_dist.logpdf(samples, args[0], args[1]),
sp_dist.logpdf(samples) - np.log(sp_dist.cdf(args[1]) - sp_dist.cdf(args[0])),
atol=1e-6)
else:
sp_dist = getattr(osp_stats, jax_dist.name)
assert_allclose(jax_dist.logpdf(samples, *args), sp_dist.logpdf(samples, *args), atol=1.3e-6)
@pytest.mark.parametrize('jax_dist, dist_args', [
(dist.dirichlet, (np.array([1., 2., 3.]),)),
], ids=idfn)
@pytest.mark.parametrize('shape', [
None,
(),
(2,),
(2, 3),
])
def test_multivariate_continuous_logpdf(jax_dist, dist_args, shape):
rng = random.PRNGKey(0)
samples = jax_dist.rvs(*dist_args, size=shape, random_state=rng)
# XXX scipy.stats.dirichlet does not work with batch
if samples.ndim == 1:
sp_dist = getattr(osp_stats, jax_dist.name)
assert_allclose(jax_dist.logpdf(samples, *dist_args),
sp_dist.logpdf(samples, *dist_args), atol=1e-6)
event_dim = len(jax_dist._event_shape(*dist_args))
batch_shape = samples.shape if event_dim == 0 else samples.shape[:-1]
assert jax_dist.logpdf(samples, *dist_args).shape == batch_shape
@pytest.mark.parametrize('jax_dist, dist_args', [
(dist.categorical, (np.array([0.7, 0.3]),)),
(dist.multinomial, (10, np.array([0.3, 0.7]),)),
], ids=idfn)
@pytest.mark.parametrize('shape', [
None,
(),
(2,),
(2, 3),
])
def test_multivariate_discrete_logpmf(jax_dist, dist_args, shape):
rng = random.PRNGKey(0)
samples = jax_dist.rvs(*dist_args, size=shape, random_state=rng)
# XXX scipy.stats.multinomial does not work with batch
if samples.ndim == 1:
if jax_dist is dist.categorical:
# test against PyTorch
assert_allclose(jax_dist.logpmf(np.array([1, 0]), *dist_args),
np.array([-1.2040, -0.3567]), atol=1e-4)
else:
sp_dist = getattr(osp_stats, jax_dist.name)
assert_allclose(jax_dist.logpmf(samples, *dist_args),
sp_dist.logpmf(samples, *dist_args), atol=1e-5)
event_dim = len(jax_dist._event_shape(*dist_args))
batch_shape = samples.shape if event_dim == 0 else samples.shape[:-1]
assert jax_dist.logpmf(samples, *dist_args).shape == batch_shape
@pytest.mark.parametrize('jax_dist, dist_args', [
(dist.bernoulli, (0.1,)),
(dist.bernoulli, (np.array([0.3, 0.5]),)),
(dist.binom, (10, 0.4)),
(dist.binom, (np.array([10]), np.array([0.4, 0.3]))),
(dist.binom, (np.array([2, 5]), np.array([[0.4], [0.5]]))),
(dist.poisson, (4.,)),
(dist.poisson, (np.array([1., 4., 10.]),)),
], ids=idfn)
@pytest.mark.parametrize('shape', [
None,
(),
(2,),
(2, 3),
])
def test_discrete_logpmf(jax_dist, dist_args, shape):
rng = random.PRNGKey(0)
sp_dist = getattr(osp_stats, jax_dist.name)
samples = jax_dist.rvs(*dist_args, random_state=rng)
assert_allclose(jax_dist.logpmf(samples, *dist_args),
sp_dist.logpmf(onp.asarray(samples), *dist_args),
rtol=1e-5)
if shape is not None:
shape = shape + lax.broadcast_shapes(*[np.shape(arg) for arg in dist_args])
samples = jax_dist.rvs(*dist_args, size=shape, random_state=rng)
assert_allclose(jax_dist.logpmf(samples, *dist_args),
sp_dist.logpmf(onp.asarray(samples), *dist_args),
rtol=1e-5)
def fn(sample, *args):
return np.sum(jax_dist.logpmf(sample, *args))
for i in range(len(dist_args)):
logpmf_grad = grad(fn, i + 1)(samples, *dist_args)
assert np.all(np.isfinite(logpmf_grad))
@pytest.mark.parametrize('jax_dist, dist_args', [
(dist.bernoulli, (0.1,)),
(dist.bernoulli, (np.array([0.3, 0.5]),)),
(dist.binom, (10, 0.4)),
(dist.binom, (np.array([10]), np.array([0.4, 0.3]))),
(dist.binom, (np.array([2, 5]), np.array([[0.4], [0.5]]))),
(dist.categorical, (np.array([0.1, 0.9]),)),
(dist.categorical, (np.array([[0.1, 0.9], [0.2, 0.8]]),)),
(dist.multinomial, (10, np.array([0.1, 0.9]),)),
(dist.multinomial, (10, np.array([[0.1, 0.9], [0.2, 0.8]]),)),
], ids=idfn)
def test_discrete_with_logits(jax_dist, dist_args):
rng = random.PRNGKey(0)
logit_to_prob = np.log if isinstance(jax_dist, jax_multivariate) else logit
logit_args = dist_args[:-1] + (logit_to_prob(dist_args[-1]),)
actual_sample = jax_dist.rvs(*dist_args, random_state=rng)
expected_sample = jax_dist(*logit_args, is_logits=True).rvs(random_state=rng)
assert_allclose(actual_sample, expected_sample)
actual_pmf = jax_dist.logpmf(actual_sample, *dist_args)
expected_pmf = jax_dist(*logit_args, is_logits=True).logpmf(actual_sample)
assert_allclose(actual_pmf, expected_pmf, rtol=1e-6)
| python |
import os
import os.path as osp
import sys
import numpy.random
import torch.nn
from deltalogger.deltalogger import Deltalogger
from reinforce_modules.utils import ConfusionGame, get_defense_visual_fool_model
from utils.train_utils import StateCLEVR, ImageCLEVR_HDF5
sys.path.insert(0, osp.abspath('.'))
import random
import argparse
from modules.embedder import *
import seaborn as sns
from reinforce_modules.policy_networks import Re1nforceTrainer, PolicyNet
sns.set_style('darkgrid')
def _print(something):
print(something, flush=True)
return
def PolicyEvaluation(args, seed=1, logger=None):
torch.manual_seed(seed)
random.seed(seed)
numpy.random.seed(seed)
effective_range_name = 'all'
BS = args.bs
TRAIN_DURATION = args.train_duration
if osp.exists(f'./results/experiment_reinforce_increasing_defense_{args.defense_level}'):
pass
else:
os.mkdir(f'./results/experiment_reinforce_increasing_defense_{args.defense_level}')
if args.backend == 'states':
load_from = './results/experiment_rn/mos_epoch_164.pt'
else:
load_from = './results/experiment_fp/mos_epoch_219.pt'
model, (
model_fool,
resnet), val_dataloader, predictions_before_pre_calc, initial_example = get_defense_visual_fool_model(
device=args.device,
load_from=load_from,
scenes_path=args.scenes_path,
questions_path=args.questions_path,
clvr_path=args.clvr_path,
batch_size=BS,
defense_level=args.defense_level)
rl_game = ConfusionGame(testbed_model=model,
confusion_model=model_fool,
device='cuda',
batch_size=BS,
confusion_weight=args.confusion_weight,
change_weight=args.change_weight,
fail_weight=args.fail_weight,
invalid_weight=args.invalid_weight,
mode=args.mode,
render=args.mode == 'visual',
backend=args.backend)
if args.backend == 'states':
input_size = 512
elif args.backend == 'pixels':
input_size = 256
else:
raise ValueError(f"Backend must be [states/pixels] you entered: {args.backend}")
model = PolicyNet(input_size=input_size, hidden_size=512, dropout=0.0, reverse_input=True)
trainer = Re1nforceTrainer(model=model,
game=rl_game,
dataloader=val_dataloader,
device=args.device,
lr=args.lr,
train_duration=TRAIN_DURATION,
batch_size=BS,
name=effective_range_name,
predictions_before_pre_calc=predictions_before_pre_calc,
resnet=resnet,
fool_model_name='Defense',
initial_example=initial_example)
best_drop, best_confusion = trainer.train(log_every=-1, save_every=100, logger=logger)
return best_drop, best_confusion
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--device', type=str, help='cpu or cuda', default='cuda')
parser.add_argument('--scenes_path', type=str, help='folder of scenes', default='data/')
parser.add_argument('--questions_path', type=str, help='folder of questions', default='data/')
parser.add_argument('--clvr_path', type=str, help='folder before images', default='data/')
parser.add_argument('--use_cache', type=int, help='if to use cache (only in image clever)', default=0)
parser.add_argument('--use_hdf5', type=int, help='if to use hdf5 loader', default=0)
parser.add_argument('--confusion_weight', type=float, help='what kind of experiment to run', default=1)
parser.add_argument('--change_weight', type=float, help='what kind of experiment to run', default=0.1)
parser.add_argument('--fail_weight', type=float, help='what kind of experiment to run', default=-0.1)
parser.add_argument('--invalid_weight', type=float, help='what kind of experiment to run', default=-0.8)
parser.add_argument('--train_duration', type=int, help='what kind of experiment to run', default=30)
parser.add_argument('--lr', type=float, help='what kind of experiment to run', default=5e-4)
parser.add_argument('--bs', type=int, help='what kind of experiment to run', default=10)
parser.add_argument('--mode', type=str, help='state | visual | imagenet', default='visual')
parser.add_argument('--range', type=float, default=-1)
parser.add_argument('--seed', type=int, default=51)
parser.add_argument('--repeat', type=int, default=1)
parser.add_argument('--backend', type=str, help='states or pixels', default='states')
parser.add_argument('--defense_level', type=int, default=10)
args = parser.parse_args()
if args.backend == 'states':
exp_name = 'DeltaDefense'
elif args.backend == 'pixels':
exp_name = 'DeltaDefensePixels'
else:
raise ValueError(f'Backend has to be one of states/pixels, you entered : {args.backend}')
if args.repeat == 1:
logger = Deltalogger(exp_name, run_tag=[args.defense_level, 0], dummy=True)
_print(PolicyEvaluation(args, args.seed, logger=logger))
else:
acc_drops = []
cons_drops = []
for seed in range(args.seed, args.repeat + args.seed):
experiment_number = seed - args.seed
logger = Deltalogger(exp_name, run_tag=[args.defense_level, experiment_number],
dummy=False)
a, c = PolicyEvaluation(args, seed, logger=logger)
acc_drops.append(a)
cons_drops.append(c)
_print(f'Accuracy: Min: {min(acc_drops)}, Mean: {sum(acc_drops) / len(acc_drops)}, Max: {max(acc_drops)}')
_print(
f'Consistency: Min: {min(cons_drops)}, Mean: {sum(cons_drops) / len(cons_drops)}, Max: {max(cons_drops)}')
| python |
from django.conf import settings
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from api.search.product import views
# Create a router and register our viewsets with it.
router = DefaultRouter()
router.register(r"search", views.ProductDocumentView, basename="product_search")
urlpatterns = [
path("", include(router.urls)),
path("suggest/", views.ProductSuggestDocumentView.as_view(), name="product_suggest"),
path("spire/<str:pk>/comment/", views.CommentView.as_view(), name="retrieve_spire_product_comment"),
path("lite/<uuid:pk>/comment/", views.CommentView.as_view(), name="retrieve_lite_product_comment"),
path("lite/<uuid:pk>/", views.RetrieveLiteProductView.as_view(), name="retrieve_lite_product"),
path("more-like-this/<str:pk>/", views.MoreLikeThisView.as_view(), name="more_like_this"),
path("more-like-this/<uuid:pk>/", views.MoreLikeThisView.as_view(), name="more_like_this"),
]
if settings.ENABLE_SPIRE_SEARCH:
urlpatterns += [
path("spire/<str:pk>/", views.RetrieveSpireProductView.as_view(), name="retrieve_spire_product"),
]
| python |
import copy
import numpy as np
# configure matplotlib for use without xserver
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
def get_neuron_features(features, neurons):
"""
Gets neuron activations from activations specified by `neurons`.
Args:
features: numpy arraylike of shape `[n,d]`
neurons: numpy arraylike of shape `[k]` (where k is the number of neuron activations to select)
used to index neuron activations from `features`. `1<=neurons[i]<=d` for all `i`
Returns:
numpy arraylike of shape `[n,k]`
"""
return np.reshape(features[:,neurons], [len(features), -1])
def mask_neuron_weights(weights, neurons, inplace=False):
"""
Zero masks rows of weights specified by neurons
Args:
weights: numpy array like of shape `[d,num_classes]`
neurons: 1D numpy array of shape `[k]`. `1<=neurons[i]<d` for all `i`
inplace: Boolean specifying whether to mask `weights` in place in addition to returning masked_vals
Returns:
masked_vals: zero masked `weights` with mask specified by `neurons`
"""
mask = np.zeros_like(weights)
mask[neurons,np.arange(mask.shape[-1])] = 1
masked_vals = weights*mask
if inplace:
weights[:] = masked_vals
return masked_vals
def get_masked_model(log_reg_model, top_neurons):
masked_log_reg_model = copy.copy(log_reg_model)
masked_log_reg_model.coef_ = mask_neuron_weights(masked_log_reg_model.coef_.T, top_neurons).T
return masked_log_reg_model
def get_top_k_neuron_weights(weights, k=1):
"""
Get's the indices of the top weights based on the l1 norm contributions of the weights
based off of https://rakeshchada.github.io/Sentiment-Neuron.html interpretation of
https://arxiv.org/pdf/1704.01444.pdf (Radford et. al)
Args:
weights: numpy arraylike of shape `[d,num_classes]`
k: integer specifying how many rows of weights to select
Returns:
k_indices: numpy arraylike of shape `[k]` specifying indices of the top k rows
"""
weight_penalties = np.squeeze(np.linalg.norm(weights, ord=1, axis=1))
if k == 1:
k_indices = np.array([np.argmax(weight_penalties)])
elif k >= np.log(len(weight_penalties)):
# runs O(nlogn)
k_indices = np.argsort(weight_penalties)[-k:][::-1]
else:
# runs O(n+klogk)
k_indices = np.argpartition(weight_penalties, -k)[-k:]
k_indices = (k_indices[np.argsort(weight_penalties[k_indices])])[::-1]
return k_indices
def plot_logit_and_save(logits, labels, logit_index, name):
"""
Plots histogram (wrt to what label it is) of logit corresponding to logit_index.
Saves plotted histogram to name.
Args:
logits:
labels:
logit_index:
name:
"""
logit = logits[:,logit_index]
plt.title('Distribution of Logit Values')
plt.ylabel('# of logits per bin')
plt.xlabel('Logit Value')
plt.hist(logit[labels < .5], bins=25, alpha=0.5, label='neg')
plt.hist(logit[labels >= .5], bins=25, alpha=0.5, label='pos')
plt.legend()
plt.savefig(name+'.png')
plt.clf()
def plot_weight_contribs_and_save(coef, name):
plt.title('Values of Resulting L1 Penalized Weights')
plt.tick_params(axis='both', which='major')
coef = normalize(coef)
plt.plot(range(len(coef[0])), coef.T)
plt.xlabel('Neuron (Feature) Index')
plt.ylabel('Neuron (Feature) weight')
plt.savefig(name)
plt.clf()
def normalize(coef):
norm = np.linalg.norm(coef)
coef = coef/norm
return coef
| python |
'''
Multiples of 3 and 5
'''
sum = 0
for i in range(1000):
if i%3 == 0 or i%5 == 0:
sum = sum + i
print sum
| python |
#!/usr/bin/env python
import sys, gym, time
#
# Test yourself as a learning agent! Pass environment name as a command-line argument, for example:
#
# python keyboard_agent.py SpaceInvadersNoFrameskip-v4
#
import gym_game
import pygame
if len(sys.argv) < 3:
print('Usage: python keyboard_agent.py ENV_NAME CONFIG_FILE')
sys.exit(-1)
env_name = sys.argv[1]
print('Making Gym[PyGame] environment:', env_name)
config_file = sys.argv[2]
print('Config file:', config_file)
env = gym.make(env_name, config_file=config_file)
sleep_time = 0.1
if not hasattr(env.action_space, 'n'):
raise Exception('Keyboard agent only supports discrete action spaces')
ACTIONS = env.action_space.n
print("ACTIONS={}".format(ACTIONS))
print("Press keys 1 2 3 ... to take actions 1 2 3 ... etc.")
print("No keys pressed is taking action 0")
render_mode = 'human'
# render_mode = 'rgb_array'
env.use_wall_clock = True
env.reset()
#env.render(render_mode)
def get_action(pressed_keys):
action = None
if pressed_keys[pygame.K_0] == 1:
action = 0
elif pressed_keys[pygame.K_1] == 1:
action = 1
elif pressed_keys[pygame.K_2] == 1:
action = 2
elif pressed_keys[pygame.K_3] == 1:
action = 3
elif pressed_keys[pygame.K_4] == 1:
action = 4
elif pressed_keys[pygame.K_5] == 1:
action = 5
elif pressed_keys[pygame.K_6] == 1:
action = 6
elif pressed_keys[pygame.K_7] == 1:
action = 7
elif pressed_keys[pygame.K_8] == 1:
action = 8
elif pressed_keys[pygame.K_9] == 1:
action = 9
if action is None:
action = 0
return action
def rollout(env):
observation = env.reset()
quit = False
total_reward = 0
total_timesteps = 0
while 1:
# Check for quit from user
events = env.get_events()
for event in events:
if event.type == pygame.QUIT:
quit = True
print('Quit event')
# Get selected action from user
pressed_keys = env.get_keys_pressed()
a = get_action(pressed_keys)
# Update the environment
observation, reward, done, info = env.step(a)
total_timesteps += 1
total_reward += reward
# print('Obs: ',str(observation))
# Render the new state
img = env.render(mode=render_mode, close=quit) # Render the game
# Handle quit request
if quit:
print('Quitting (truncating rollout)...')
break
if done:
print('Episode (rollout) complete.')
env.reset()
break
# Wait a short time
time.sleep(sleep_time)
print("Rollout summary: Timesteps %i Reward %0.2f" % (total_timesteps, total_reward))
return quit
while 1:
quit = rollout(env)
if quit:
break
| python |
import enum
import re
import string
from typing import Text, List
from xml.sax import saxutils
import emoji
from six import string_types
from collections.abc import Iterable
from tklearn.preprocessing import TextPreprocessor
__all__ = [
'Normalize',
'TweetPreprocessor',
]
@enum.unique
class Normalize(enum.Enum):
NONE = 0
ALL = 1
LINKS = 2
HASHTAGS = 3
MENTIONS = 4
IMAGES = 5
class TweetPreprocessor(TextPreprocessor):
""" Preprocessor for Tweets.
Instance of this class can be used to create a preprocessor for tour tweet data.
Several options are provided and you might be using them according to your use case.
"""
RE_LINKS = re.compile(r'(https?://\S+)')
RE_IMAGE_LINKS = re.compile(r'(pic.twitter.com\S+)')
RE_MENTIONS = re.compile(r'(@[a-zA-Z0-9_]{1,15})')
RE_HASHTAGS = re.compile(r'(#\w+)')
def __init__(self, normalize=Normalize.NONE, lowercase=False, **kwargs):
""" Initialize `TweetPreprocessor` object.
Parameters
----------
kwargs
Parameters
"""
super(TweetPreprocessor, self).__init__()
self.normalize = []
self.lowercase = lowercase
if normalize == Normalize.ALL:
self.normalize = [
Normalize.LINKS,
Normalize.HASHTAGS,
Normalize.MENTIONS,
Normalize.IMAGES,
]
elif (normalize != Normalize.NONE) and isinstance(normalize, Iterable):
for item in normalize:
if isinstance(item, string_types):
if not item.endswith('s'):
item = '{}s'.format(item)
item = Normalize[item.upper()]
self.normalize.append(item)
@staticmethod
def _replace(s: List[Text], old: Text, new: Text) -> List[Text]:
return [new if x == old else x for x in s if x.strip() != '']
def preprocess(self, s: Text) -> Text:
""" Preprocess the input text. Expected input is a Tweet text.
Parameters
----------
s
Input Tweet text.
Returns
-------
Preprocessed tweet.
"""
s = self._clean_tweet(s)
if Normalize.LINKS in self.normalize:
s = self.RE_LINKS.sub('<link>', s)
if Normalize.IMAGES in self.normalize:
s = self.RE_IMAGE_LINKS.sub('<image>', s)
if Normalize.HASHTAGS in self.normalize:
s = self.RE_HASHTAGS.sub('<hashtag>', s)
if Normalize.MENTIONS in self.normalize:
s = self.RE_MENTIONS.sub('<mention>', s)
tokens = s.split()
for ns in self.normalize:
if isinstance(ns, str):
pass
elif isinstance(ns, tuple):
assert len(ns) == 2, \
'Required a tuple of size 2 indicating (new_word, old_words) values for the normalization.'
assert isinstance(ns[1], list), \
'Required a list of old values to replace with the new value.'
for n in ns[1]:
tokens = self._replace(tokens, n, ns[0])
if self.lowercase:
return ' '.join(tokens).lower()
else:
return ' '.join(tokens)
@staticmethod
def _clean_tweet(x):
""" Cleans a given text (tweet) while keeping important characters.
Parameters
----------
x
Input String.
Returns
-------
Cleaned Text.
"""
x = saxutils.unescape(x)
x = x.replace('\xa0', ' ')
x = emoji.demojize(x)
x = ''.join(filter(lambda item: item in set(string.printable), x))
x = emoji.emojize(x)
return x
| python |
from flask import Flask, request, jsonify, render_template
from flask_cors import CORS
import math
import pickle
app = Flask(__name__)
CORS(app)
uniq_fire_date = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'July', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
uniq_county = ['No Data', 'Skamania', 'Cowlitz', 'Thurston', 'Okanogan', 'Pacific', 'Clark', 'Columbia', 'Grays Harbor', 'Adams', 'Benton', 'Asotin', 'Stevens', 'Chelan', 'Klickitat', 'King', 'Lewis', 'Douglas', 'Franklin', 'Jefferson', 'San Juan', 'Kittitas', 'Garfield', 'Grant', 'Pierce', 'Wahkiakum', 'Ferry', 'Clallam', 'Spokane', 'Mason', 'Skagit', 'Pend Oreille', 'Walla Walla', 'Whatcom', 'Kitsap', 'Lincoln', 'Island', 'Snohomish', 'Yakima', 'Whitman']
uniq_cause = ['Smoker', 'Miscellaneou', 'Under Invest', 'Logging', 'Debris Burn', 'Undetermined', 'Recreation', 'Railroad', 'Lightning', 'Children', 'Arson', 'None']
uniq_binlat = [1, 2, 3, 4]
uniq_binlon = [1, 2, 3, 4, 5, 6, 7, 8]
uniq_binacres = [2, 3, 4, 5, 6, 7, 8, 9]
# def binLat(lat):
# print(lat)
# if lat > 48:
# return 1
# elif 48 >= lat > 47:
# return 2
# elif 47 >= lat > 46:
# return 3
# elif 46 >= lat > 45:
# return 4
# else:
# return 5
# def binLon(lon):
# if lon < -124:
# return 1
# elif -124 <= lon < -123:
# return 2
# elif -123 <= lon < -122:
# return 3
# elif -122 <= lon < -121:
# return 4
# elif -121 <= lon < -120:
# return 5
# elif -120 <= lon < -119:
# return 6
# elif -119 <= lon < -118:
# return 7
# else:
# return 8
def unBinAcres(acres_binned):
if acres_binned == 1:
return "0-2"
elif acres_binned == 2:
return "2-10"
elif acres_binned == 3:
return "10-50"
elif acres_binned == 4:
return "50-100"
elif acres_binned == 5:
return "100-500"
elif acres_binned == 6:
return "500-2000"
elif acres_binned == 7:
return "2000-10000"
elif acres_binned == 8:
return "10000-50000"
elif acres_binned == 9:
return "50000-300000"
else:
return "Failure to Compute..."
def acres_to_circle_radius_in_miles(acres):
sqft = acres * 43560
radius = math.sqrt(sqft / math.pi)
return radius / 5280
@app.route('/', methods=['GET'])
def main_route():
return render_template('index.html',
mth=uniq_fire_date,
cnt=uniq_county,
cau=uniq_cause,
lat=uniq_binlat,
lon=uniq_binlon,
acr=uniq_binacres)
@app.route('/api/predict', methods=["GET"])
def return_prediction():
acres = 10000
cause = request.args.get("cause", "")
county = request.args.get("county", "")
fire_date = request.args.get("month", "")
lat = request.args.get("binlat", "")
lon = request.args.get("binlon", "")
# lat = binLat(float(lat))
# lon = binLon(float(lon))
instance = [fire_date, county, cause, lat, lon]
infile = open("trees.p", "rb")
best_trees = pickle.load(infile)
infile.close()
prediction = predict_acres([instance], best_trees)
print(prediction)
if prediction is not None:
acres_binned = prediction[0]
result = {"prediction": unBinAcres(acres_binned)}
return jsonify(result), 200
else:
# failure!!
return "Error making prediction", 400
def predict_acres(X_test, best_trees):
header = []
predictions = []
for i in range(0, len(X_test[0])):
header.append("att" + str(i))
for instance in X_test:
tree_predictions = {}
for tree in best_trees:
temp = tree['tree']
prediction = tdidt_predict(header, tree['tree'], instance)
if prediction in tree_predictions:
tree_predictions[prediction] += 1
else:
tree_predictions[prediction] = 1
max_key = max(tree_predictions, key = tree_predictions.get)
predictions.append(max_key)
return predictions
def tdidt_predict(header, tree, instance):
info_type = tree[0]
if info_type == "Attribute":
attribute_index = header.index(tree[1])
instance_value = instance[attribute_index]
# now I need to find which "edge" to follow recursively
for i in range(2, len(tree)):
value_list = tree[i]
if value_list[1] == instance_value:
# we have a match!! recurse!!
return tdidt_predict(header, value_list[2], instance)
else: # "Leaf"
return tree[1] # leaf class label
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8888) | python |
def mallow(y, y_pred, y_sub, k, p):
"""
Return an mallows Cp score for a model.
Input:
y: array-like of shape = (n_samples) including values of observed y
y_pred: vector including values of predicted y
k: int number of predictive variable(s) used in the model
p: int number of predictive variable(s) used in the sub model
Output:
mallow_score: int or float Mallows Cp score of the model and sub model
Raise InputError if k is less than p.
Raise InputError if y , y_sub and y_pred are not in same length.
Raise InputError if length(y) <= 1, length(y_sub)<=1, or length(y_pred) <= 1.
Raise TypeError if y , y_sub and y_pred are not vector.
Raise TypeError if p is not int.
Raise InputError if p < 0.
Raise TypeError if k is not int.
Raise InputError if k < 0.
"""
import numpy as np
import pandas as pd
if k<p:
raise ValueError("number of predictive variable(s) used in the model must larger than in subset model")
if len(y)!=len(y_sub) or len(y_sub)!=len(y_pred) or len(y)!= len(y_pred):
raise ValueError("The length of observed y, predicted y, and predicted y in subset model must be same")
if len(y)<=1 or len(y_sub)<=1 or len(y)<=1:
raise ValueError("The length of observed y, predicted y, and predicted y in subset model must be larger than 1")
if isinstance(y, (np.ndarray, list, tuple, pd.core.series.Series)) == False or isinstance(y_pred, (np.ndarray, list, tuple, pd.core.series.Series)) == False:
raise TypeError("The observed y, predicted y, and predicted y in subset model must be array-like shape (e.g. array, list, tuple, data column)")
else:
for i in y:
for j in y_pred:
if isinstance(i, (int, float)) != True or isinstance(j, (int, float)) != True:
raise TypeError("The observed y, predicted y, and predicted y in subset model must be numeric elements")
if isinstance(p,int) !=True or isinstance(k,int)!=True:
raise TypeError("The number of predictive variable(s) used in the sub model must be integer")
if p<=0 or k<=0:
raise Exception("The number of predictive variable(s) used in the sub model must be positive")
if isinstance(y,list)==True:
y=np.array(y)
if isinstance(y_sub,list)==True:
y_sub=np.array(y_sub)
if isinstance(y_pred,list)==True:
y_pred=np.array(y_pred)
SSE_p=np.sum((y-y_sub)**2)
MSE= np.sum((y-y_pred)**2)/(len(y)-k)
mallowcp=SSE_p/MSE-len(y)+2*p
return mallowcp
| python |
import functools,fractions
n=int(input())
a=list(map(int,input().split()))
print(functools.reduce(fractions.gcd,a)) | python |
from pymining import itemmining
from pymining import seqmining
import sys
if(len(sys.argv) != 3):
print("Please provide the data file and the minimum support as input, e.g., python freq_seq.py ./output.txt 40")
sys.exit(-1)
f = open(sys.argv[1], 'r')
lines = f.read().splitlines()
seqs = []
for s in lines:
seq = s.split("---")[1]
seq = seq[1:-1]
seqs.append(seq.split(", "))
freq_seqs = seqmining.freq_seq_enum(seqs, int(sys.argv[2]))
for p in freq_seqs:
print(p)
| python |
"""
属性的使用
- 访问器/修改器/删除器
- 使用__slots__对属性加以限制
Version: 0.1
Author: BDFD
Date: 2018-03-12
"""
class Car(object):
__slots__ = ('_brand', '_max_speed')
def __init__(self, brand, max_speed):
self._brand = brand
self._max_speed = max_speed
@property
def brand(self):
return self._brand
@brand.setter
def brand(self, brand):
self._brand = brand
@brand.deleter
def brand(self):
del self._brand
@property
def max_speed(self):
return self._max_speed
@max_speed.setter
def max_speed(self, max_speed):
if max_speed < 0:
raise ValueError('Invalid max speed for car')
self._max_speed = max_speed
def __str__(self):
return 'Car: [品牌=%s, 最高时速=%d]' % (self._brand, self._max_speed)
car = Car('QQ', 120)
print(car)
# ValueError
# car.max_speed = -100
car.max_speed = 320
car.brand = "Benz"
# 使用__slots__属性限制后下面的代码将产生异常
# car.current_speed = 80
print(car)
# 如果提供了删除器可以执行下面的代码
# del car.brand
# 属性的实现
print(Car.brand)
print(Car.brand.fget)
print(Car.brand.fset)
print(Car.brand.fdel)
# 通过上面的代码帮助学生理解之前提到的包装器的概念
# Python中有很多类似的语法糖后面还会出现这样的东西
| python |
# Lint as: python3
# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for confusion matrix at thresholds."""
from __future__ import absolute_import
from __future__ import division
# Standard __future__ imports
from __future__ import print_function
import math
from absl.testing import parameterized
import apache_beam as beam
from apache_beam.testing import util
import numpy as np
import tensorflow as tf
from tensorflow_model_analysis.eval_saved_model import testutil
from tensorflow_model_analysis.metrics import confusion_matrix_metrics
from tensorflow_model_analysis.metrics import metric_types
from tensorflow_model_analysis.metrics import metric_util
class ConfusionMatrixMetricsTest(testutil.TensorflowModelAnalysisTest,
parameterized.TestCase):
@parameterized.named_parameters(
('specificity', confusion_matrix_metrics.Specificity(), 2.0 /
(2.0 + 3.0)),
('fall_out', confusion_matrix_metrics.FallOut(), 3.0 / (3.0 + 2.0)),
('miss_rate', confusion_matrix_metrics.MissRate(), 4.0 / (4.0 + 1.0)),
('negative_predictive_value',
confusion_matrix_metrics.NegativePredictiveValue(), 2.0 / (2.0 + 4.0)),
('false_discovery_rate', confusion_matrix_metrics.FalseDiscoveryRate(),
3.0 / (3.0 + 1.0)),
('false_omission_rate', confusion_matrix_metrics.FalseOmissionRate(),
4.0 / (4.0 + 2.0)),
('prevalence', confusion_matrix_metrics.Prevalence(),
(1.0 + 4.0) / (1.0 + 2.0 + 3.0 + 4.0)),
('prevalence_threshold', confusion_matrix_metrics.PrevalenceThreshold(),
(math.sqrt((1.0 / (1.0 + 4.0)) * (1.0 - 1.0 * (2.0 / (2.0 + 3.0)))) +
(2.0 / (2.0 + 3.0) - 1.0)) / ((1.0 / (1.0 + 4.0) +
(2.0 / (2.0 + 3.0)) - 1.0))),
('threat_score', confusion_matrix_metrics.ThreatScore(), 1.0 /
(1.0 + 4.0 + 3.0)),
('balanced_accuracy', confusion_matrix_metrics.BalancedAccuracy(),
((1.0 / (1.0 + 4.0)) + (2.0 / (2.0 + 3.0))) / 2),
('f1_score', confusion_matrix_metrics.F1Score(), 2 * 1.0 /
(2 * 1.0 + 3.0 + 4.0)),
('matthews_correlation_coefficient',
confusion_matrix_metrics.MatthewsCorrelationCoefficent(),
(1.0 * 2.0 - 3.0 * 4.0) / math.sqrt(
(1.0 + 3.0) * (1.0 + 4.0) * (2.0 + 3.0) * (2.0 + 4.0))),
('fowlkes_mallows_index', confusion_matrix_metrics.FowlkesMallowsIndex(),
math.sqrt(1.0 / (1.0 + 3.0) * 1.0 / (1.0 + 4.0))),
('informedness', confusion_matrix_metrics.Informedness(),
(1.0 / (1.0 + 4.0)) + (2.0 / (2.0 + 3.0)) - 1.0),
('markedness', confusion_matrix_metrics.Markedness(),
(1.0 / (1.0 + 3.0)) + (2.0 / (2.0 + 4.0)) - 1.0),
('positive_likelihood_ratio',
confusion_matrix_metrics.PositiveLikelihoodRatio(),
(1.0 / (1.0 + 4.0)) / (3.0 / (3.0 + 2.0))),
('negative_likelihood_ratio',
confusion_matrix_metrics.NegativeLikelihoodRatio(),
(4.0 / (4.0 + 1.0)) / (2.0 / (2.0 + 3.0))),
('diagnostic_odds_ratio', confusion_matrix_metrics.DiagnosticOddsRatio(),
((1.0 / 3.0)) / (4.0 / 2.0)),
)
def testConfusionMatrixMetrics(self, metric, expected_value):
computations = metric.computations()
histogram = computations[0]
matrices = computations[1]
metrics = computations[2]
# tp = 1
# tn = 2
# fp = 3
# fn = 4
example1 = {
'labels': np.array([1.0]),
'predictions': np.array([0.6]),
'example_weights': np.array([1.0]),
}
example2 = {
'labels': np.array([0.0]),
'predictions': np.array([0.3]),
'example_weights': np.array([1.0]),
}
example3 = {
'labels': np.array([0.0]),
'predictions': np.array([0.2]),
'example_weights': np.array([1.0]),
}
example4 = {
'labels': np.array([0.0]),
'predictions': np.array([0.6]),
'example_weights': np.array([1.0]),
}
example5 = {
'labels': np.array([0.0]),
'predictions': np.array([0.7]),
'example_weights': np.array([1.0]),
}
example6 = {
'labels': np.array([0.0]),
'predictions': np.array([0.8]),
'example_weights': np.array([1.0]),
}
example7 = {
'labels': np.array([1.0]),
'predictions': np.array([0.1]),
'example_weights': np.array([1.0]),
}
example8 = {
'labels': np.array([1.0]),
'predictions': np.array([0.2]),
'example_weights': np.array([1.0]),
}
example9 = {
'labels': np.array([1.0]),
'predictions': np.array([0.3]),
'example_weights': np.array([1.0]),
}
example10 = {
'labels': np.array([1.0]),
'predictions': np.array([0.4]),
'example_weights': np.array([1.0]),
}
with beam.Pipeline() as pipeline:
# pylint: disable=no-value-for-parameter
result = (
pipeline
| 'Create' >> beam.Create([
example1, example2, example3, example4, example5, example6,
example7, example8, example9, example10
])
| 'Process' >> beam.Map(metric_util.to_standard_metric_inputs)
| 'AddSlice' >> beam.Map(lambda x: ((), x))
| 'ComputeHistogram' >> beam.CombinePerKey(histogram.combiner)
| 'ComputeMatrices' >> beam.Map(
lambda x: (x[0], matrices.result(x[1]))) # pyformat: ignore
| 'ComputeMetrics' >> beam.Map(lambda x: (x[0], metrics.result(x[1])))
) # pyformat: ignore
# pylint: enable=no-value-for-parameter
def check_result(got):
try:
self.assertLen(got, 1)
got_slice_key, got_metrics = got[0]
self.assertEqual(got_slice_key, ())
self.assertLen(got_metrics, 1)
key = metrics.keys[0]
self.assertDictElementsAlmostEqual(
got_metrics, {key: expected_value}, places=5)
except AssertionError as err:
raise util.BeamAssertException(err)
util.assert_that(result, check_result, label='result')
def testConfusionMatrixMetricsWithNan(self):
computations = confusion_matrix_metrics.Specificity().computations()
histogram = computations[0]
matrices = computations[1]
metrics = computations[2]
example1 = {
'labels': np.array([1.0]),
'predictions': np.array([1.0]),
'example_weights': np.array([1.0]),
}
with beam.Pipeline() as pipeline:
# pylint: disable=no-value-for-parameter
result = (
pipeline
| 'Create' >> beam.Create([example1])
| 'Process' >> beam.Map(metric_util.to_standard_metric_inputs)
| 'AddSlice' >> beam.Map(lambda x: ((), x))
| 'ComputeHistogram' >> beam.CombinePerKey(histogram.combiner)
| 'ComputeMatrices' >> beam.Map(
lambda x: (x[0], matrices.result(x[1]))) # pyformat: ignore
| 'ComputeMetrics' >> beam.Map(lambda x: (x[0], metrics.result(x[1])))
) # pyformat: ignore
# pylint: enable=no-value-for-parameter
def check_result(got):
try:
self.assertLen(got, 1)
got_slice_key, got_metrics = got[0]
self.assertEqual(got_slice_key, ())
self.assertLen(got_metrics, 1)
key = metrics.keys[0]
self.assertIn(key, got_metrics)
self.assertTrue(math.isnan(got_metrics[key]))
except AssertionError as err:
raise util.BeamAssertException(err)
util.assert_that(result, check_result, label='result')
def testConfusionMatrixAtThresholds(self):
computations = confusion_matrix_metrics.ConfusionMatrixAtThresholds(
thresholds=[0.3, 0.5, 0.8]).computations()
histogram = computations[0]
matrices = computations[1]
metrics = computations[2]
example1 = {
'labels': np.array([0.0]),
'predictions': np.array([0.0]),
'example_weights': np.array([1.0]),
}
example2 = {
'labels': np.array([0.0]),
'predictions': np.array([0.5]),
'example_weights': np.array([1.0]),
}
example3 = {
'labels': np.array([1.0]),
'predictions': np.array([0.3]),
'example_weights': np.array([1.0]),
}
example4 = {
'labels': np.array([1.0]),
'predictions': np.array([0.9]),
'example_weights': np.array([1.0]),
}
with beam.Pipeline() as pipeline:
# pylint: disable=no-value-for-parameter
result = (
pipeline
| 'Create' >> beam.Create([example1, example2, example3, example4])
| 'Process' >> beam.Map(metric_util.to_standard_metric_inputs)
| 'AddSlice' >> beam.Map(lambda x: ((), x))
| 'ComputeHistogram' >> beam.CombinePerKey(histogram.combiner)
| 'ComputeMatrices' >> beam.Map(
lambda x: (x[0], matrices.result(x[1]))) # pyformat: ignore
| 'ComputeMetrics' >> beam.Map(lambda x: (x[0], metrics.result(x[1])))
) # pyformat: ignore
# pylint: enable=no-value-for-parameter
def check_result(got):
try:
self.assertLen(got, 1)
got_slice_key, got_metrics = got[0]
self.assertEqual(got_slice_key, ())
self.assertLen(got_metrics, 1)
key = metric_types.MetricKey(name='confusion_matrix_at_thresholds')
self.assertIn(key, got_metrics)
got_metric = got_metrics[key]
self.assertProtoEquals(
"""
matrices {
threshold: 0.3
false_negatives: 1.0
true_negatives: 1.0
false_positives: 1.0
true_positives: 1.0
precision: 0.5
recall: 0.5
}
matrices {
threshold: 0.5
false_negatives: 1.0
true_negatives: 2.0
true_positives: 1.0
precision: 1.0
recall: 0.5
}
matrices {
threshold: 0.8
false_negatives: 1.0
true_negatives: 2.0
true_positives: 1.0
precision: 1.0
recall: 0.5
}
""", got_metric)
except AssertionError as err:
raise util.BeamAssertException(err)
util.assert_that(result, check_result, label='result')
if __name__ == '__main__':
tf.test.main()
| python |
# Generated by Django 4.0.2 on 2022-02-19 14:09
from django.conf import settings
import django.core.validators
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Review',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('rating', models.IntegerField(validators=[django.core.validators.MaxValueValidator(5), django.core.validators.MinValueValidator(1)])),
('text', models.TextField(blank=True, default='')),
('created', models.DateTimeField(auto_now_add=True)),
('is_published', models.BooleanField(default=False)),
('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
options={
'ordering': ['-created'],
},
),
]
| python |
import cv2
import numpy as np
import torch
from ..builder import MOTION
@MOTION.register_module()
class CameraMotionCompensation(object):
"""Camera motion compensation.
Args:
warp_mode (str): Warp mode in opencv.
num_iters (int): Number of the iterations.
stop_eps (float): Terminate threshold.
"""
def __init__(self,
warp_mode='cv2.MOTION_EUCLIDEAN',
num_iters=50,
stop_eps=0.001):
self.warp_mode = eval(warp_mode)
self.num_iters = num_iters
self.stop_eps = stop_eps
def get_warp_matrix(self, img, ref_img):
"""Calculate warping matrix between two images."""
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
ref_img = cv2.cvtColor(ref_img, cv2.COLOR_RGB2GRAY)
warp_matrix = np.eye(2, 3, dtype=np.float32)
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
self.num_iters, self.stop_eps)
cc, warp_matrix = cv2.findTransformECC(img, ref_img, warp_matrix,
self.warp_mode, criteria, None,
1)
warp_matrix = torch.from_numpy(warp_matrix)
return warp_matrix
def warp_bboxes(self, bboxes, warp_matrix):
"""Warp bounding boxes according to the warping matrix."""
tl, br = bboxes[:, :2], bboxes[:, 2:]
tl = torch.cat((tl, torch.ones(tl.shape[0], 1).to(bboxes.device)),
dim=1)
br = torch.cat((br, torch.ones(tl.shape[0], 1).to(bboxes.device)),
dim=1)
trans_tl = torch.mm(warp_matrix, tl.t()).t()
trans_br = torch.mm(warp_matrix, br.t()).t()
trans_bboxes = torch.cat((trans_tl, trans_br), dim=1)
return trans_bboxes.to(bboxes.device)
def track(self, img, ref_img, tracks, num_samples, frame_id):
"""Tracking forward."""
img = img.squeeze(0).cpu().numpy().transpose((1, 2, 0))
ref_img = ref_img.squeeze(0).cpu().numpy().transpose((1, 2, 0))
warp_matrix = self.get_warp_matrix(img, ref_img)
bboxes = []
num_bboxes = []
for k, v in tracks.items():
if int(v['frame_ids'][-1]) < frame_id - 1:
_num = 1
else:
_num = min(num_samples, len(v.bboxes))
num_bboxes.append(_num)
bboxes.extend(v.bboxes[-_num:])
bboxes = torch.cat(bboxes, dim=0)
warped_bboxes = self.warp_bboxes(bboxes, warp_matrix.to(bboxes.device))
warped_bboxes = torch.split(warped_bboxes, num_bboxes)
for b, (k, v) in zip(warped_bboxes, tracks.items()):
_num = b.shape[0]
b = torch.split(b, [1] * _num)
tracks[k].bboxes[-_num:] = b
return tracks
| python |
""" Access to data resources installed with this package
"""
from servicelib.resources import ResourcesFacade
resources = ResourcesFacade(
package_name=__name__,
distribution_name="simcore-service-storage",
config_folder="",
)
| python |
#!/usr/bin/env python
import time
from slackclient import SlackClient
import os, re
base_dir = os.path.dirname(os.path.realpath(__file__))
player = 'afplay'
text2voice = 'espeak'
sounds_dir = 'sounds'
filetype = 'mp3'
debug = True
bots_channel = 'build'
play_fixed = re.compile("FIXED")
play_cancelled = re.compile("CANCELLED")
play_failed = re.compile("FAILED")
play_broken = re.compile("BROKEN")
play_building = re.compile("BUILDING")
add_sound_regex = re.compile("^add-sound\s([a-z0-9]+)\s<?(https?:\/\/[a-z./]*\?v=[a-zA-Z0-9_-]*)>?(\s([0-9.]*)\s([0-9.]*)$)?")
def action(command, message):
global debug
global sc
global bots_channel
sc.rtm_send_message(bots_channel, message)
if debug: print ('Running command: ' + command)
os.system(command)
whitelist = {}
with open(os.path.join(base_dir, 'whitelist.txt')) as f:
for line in f:
(name, identifier) = line.split()
whitelist[identifier] = name
f = open(os.path.join(base_dir, 'token.txt'))
token = f.readline().rstrip()
f.close()
print ("Connecting using token " + token)
sc = SlackClient(token)
if sc.rtm_connect():
while True:
for event in sc .rtm_read():
if 'type' in event and event['type'] == 'message' and 'text' in event:
if ('user' in event and event['user'] in whitelist.keys()):
user = whitelist[event['user']]
elif ('subtype' in event and event['subtype'] == 'bot_message' and 'bot_id' in event and event['bot_id'] in whitelist.keys()):
user = whitelist[event['bot_id']]
else:
user = False
if user:
if debug: print ("Parsing message from " + user + ": '" + event['attachments'][0]['fallback'] + "'")
add_sound_match = add_sound_regex.match(event['attachments'][0]['fallback'])
fixed = play_fixed.search(event['attachments'][0]['fallback'])
cancelled = play_cancelled.search(event['attachments'][0]['fallback'])
failed = play_failed.search(event['attachments'][0]['fallback'])
broken = play_broken.search(event['attachments'][0]['fallback'])
building = play_building.search(event['attachments'][0]['fallback'])
if fixed:
message = user + ' FIXED '
sound_file = os.path.join(base_dir, sounds_dir, 'dai' + '.' + filetype)
command = player + ' ' + sound_file
action(command, message)
elif cancelled:
message = user + ' CANCELLED '
sound_file = os.path.join(base_dir, sounds_dir, 'noooo' + '.' + filetype)
command = player + ' ' + sound_file
action(command, message)
elif failed:
message = user + ' FAILED '
sound_file = os.path.join(base_dir, sounds_dir, 'heygirl' + '.' + filetype)
command = player + ' ' + sound_file
action(command, message)
elif broken:
message = user + ' BROKEN '
sound_file = os.path.join(base_dir, sounds_dir, 'horror' + '.' + filetype)
command = player + ' ' + sound_file
action(command, message)
elif building:
message = user + ' BUILDING '
sound_file = os.path.join(base_dir, sounds_dir, 'dangerzone' + '.' + filetype)
command = player + ' ' + sound_file
action(command, message)
elif add_sound_match:
message = user + ' adds sound ' + add_sound_match.group(1) + ' from youtube video ' + add_sound_match.group(2)
command = os.path.join(base_dir, 'yt-add-sound.sh') + ' ' + add_sound_match.group(1) + ' ' + add_sound_match.group(2)
if add_sound_match.group(3): command += add_sound_match.group(3)
action(command, message)
time.sleep(1);
else:
print ('Connection failed, invalid token?') | python |
"""
Produces Fig. A1 of Johnson & Weinberg (2020), a single axis plot showing the
abundance data of several dwarf galaxies taken from Kirby et al. (2010) in
comparison to a smooth and single-burst model simulated in VICE.
"""
import visuals # visuals.py -> matplotlib subroutines in this directory
import matplotlib.pyplot as plt
import vice
import sys
import warnings
warnings.filterwarnings("ignore")
_NAMES_ = {
"Scl": "Sculptor",
"LeoI": "Leo I",
"Sex": "Sextans",
"LeoII": "Leo II",
"CVnI": "Canes Venatici I",
"UMi": "Ursa Minor",
"Dra": "Draco"
}
_COLORS_ = {
"Scl": "crimson",
"LeoI": "grey",
"Sex": "lime",
"LeoII": "deepskyblue",
"CVnI": "darkviolet",
"UMi": "black",
"Dra": "gold"
}
_MARKERS_ = {
"Scl": "circle",
"LeoI": "square",
"Sex": "star",
"LeoII": "thin_diamond",
"CVnI": "pentagon",
"UMi": "hexagon2",
"Dra": "triangle_up"
}
_SIZES_ = {
"Scl": 30,
"LeoI": 10,
"Sex": 80,
"LeoII": 30,
"CVnI": 60,
"UMi": 50,
"Dra": 40
}
def setup_axis():
"""
Sets up the axis with the proper labels and ranges
Returns
=======
axis :: matplotlib subplot
The axis to plot the data on
"""
fig = plt.figure(figsize = (10, 7))
ax = fig.add_subplot(111, facecolor = "white")
ax.set_xlabel("[Fe/H]")
ax.set_ylabel("[Mg/Fe]")
ax.set_xlim([-3.2, -0.4])
ax.set_ylim([-0.9, 1.4])
return ax
def read_data(filename = "../../data/kirby2010processed.dat"):
"""
Import the data from the associated file.
Args
====
filename :: str [default :: ../data/kirby2010processed.dat]
The path to the data file
Returns
=======
An 2D-ascii list containing the data as it appears in the file
"""
data = 849 * [None]
with open(filename, 'r') as f:
f.readline() # header
for i in range(len(data)):
data[i] = f.readline().split()
for j in range(2, len(data[i])):
data[i][j] = float(data[i][j])
f.close()
return data
def plot_data(ax, data, dwarf):
"""
Plots an individual dwarf galaxy's abundance data on the subplot.
Parameters
==========
ax :: matplotlib subplot
The axis to plot the abundance data on
data :: 2D-list
The raw data itself
dwarf :: str
A key denoting which dwarf is being plotted. These appear in the first
column of the argument data.
"""
FeH_column = 12
MgFe_column = 14
fltrd = list(filter(lambda x: x[0] == dwarf, data))
kwargs = {
"c": visuals.colors()[_COLORS_[dwarf]],
"marker": visuals.markers()[_MARKERS_[dwarf]],
"linestyle": "None",
"label": _NAMES_[dwarf],
"s": _SIZES_[dwarf]
}
if dwarf == "LeoI": kwargs["zorder"] = 0
ax.scatter(
[row[FeH_column] for row in fltrd],
[row[MgFe_column] for row in fltrd],
**kwargs
)
def plot_representative_errorbar(ax, data, dwarf):
"""
Plots a representative error bar in the lower-left corner of the figure
Parameters
==========
ax :: matplotlib subplot
The axis object to put the errorbar on
data :: 2D-list
The raw data itself
dwarf :: str
The name of the dwarf to take the median errors from
"""
err_FeH_column = 13
err_MgFe_column = 15
fltrd = list(filter(lambda x: x[0] == dwarf, data))
ax.errorbar(-2.8, -0.4,
xerr = sorted([row[err_FeH_column] for row in fltrd])[len(fltrd) // 2],
yerr = sorted([row[err_MgFe_column] for row in fltrd])[len(fltrd) // 2],
ms = 0, color = visuals.colors()[_COLORS_[dwarf]])
def plot_vice_comparison(ax, name):
"""
Plots the [Mg/Fe]-[Fe/H] track of a given VICE model on the subplot.
Parameters
==========
ax :: matplotlib subplot
The axis to plot on
name :: str
The relative path to the VICE output
"""
out = vice.output(name)
ax.plot(out.history["[fe/h]"], out.history["[mg/fe]"],
c = visuals.colors()["black"],
linestyle = '--')
def main():
"""
Produces the figure and saves it as a PDF.
"""
plt.clf()
ax = setup_axis()
data = read_data()
for i in _NAMES_.keys():
plot_data(ax, data, i)
plot_vice_comparison(ax, "../../simulations/kirby2010_smooth_enh1")
plot_vice_comparison(ax, "../../simulations/kirby2010_smooth")
plot_vice_comparison(ax, "../../simulations/kirby2010_burst")
plot_representative_errorbar(ax, data, "UMi")
ax.legend(loc = visuals.mpl_loc()["upper left"], ncol = 1, frameon = False,
bbox_to_anchor = (1.02, 0.98), fontsize = 18)
plt.tight_layout()
plt.savefig(sys.argv[1])
plt.clf()
if __name__ == "__main__":
main()
| python |
# Copyright © 2021 Lynx-Userbot (LLC Company (WARNING))
# GPL-3.0 License From Github (General Public License)
# Ported From Cat Userbot For Lynx-Userbot By Alvin/LiuAlvinas.
# Based On Plugins
# Credits @Cat-Userbot by Alvin from Lord-Userbot
from userbot.events import register
from userbot import CMD_HELP, bot
from telethon.errors.rpcerrorlist import YouBlockedUserError
# Ported by KENZO @TeamSecret_Kz
@register(outgoing=True, pattern=r"^\.detect(?: |$)(.*)")
async def detect(event):
if event.fwd_from:
return
input_str = "".join(event.text.split(maxsplit=1)[1:])
reply_message = await event.get_reply_message()
if not event.reply_to_msg_id:
await event.edit("```Please reply to the user or type .detect (ID/Username) that you want to detect.```")
return
if input_str:
try:
lynxuser = int(input_str)
except ValueError:
try:
u = await event.client.get_entity(input_str)
except ValueError:
await edit.event("`Please Give ID/Username to Find History.`"
)
lynxuser = u.id
else:
lynxuser = reply_message.sender_id
chat = "@tgscanrobot"
event = await event.edit("`Currently Doing Account Detection...`")
event = await event.edit("__Connecting to server telegram.__")
event = await event.edit("__Connecting to server telegram..__")
event = await event.edit("__Connecting to server telegram...__")
event = await event.edit("__Connecting to server telegram.__")
event = await event.edit("__Connecting to server telegram..__")
event = await event.edit("__Connecting to server telegram...__")
event = await event.edit("__Connecting to server telegram.__")
event = await event.edit("__Connecting to server telegram..__")
event = await event.edit("__Connecting to server telegram...__")
event = await event.edit("__Connecting to server telegram.__")
event = await event.edit("__Connecting to server telegram..__")
event = await event.edit("__Connecting to server telegram...__")
async with bot.conversation(chat) as conv:
try:
await conv.send_message(f"{lynxuser}")
except YouBlockedUserError:
await steal.reply(
"```Please Unblock @tgscanrobot And Try Again.```"
)
response = await conv.get_response()
await event.client.send_read_acknowledge(conv.chat_id)
await event.edit(response.text)
def inline_mention(user):
full_name = user_full_name(user) or "No Name"
return f"[{full_name}](tg://user?id={user.id})"
def user_full_name(user):
names = [user.first_name, user.last_name]
names = [i for i in list(names) if i]
return " ".join(names)
CMD_HELP.update({
"detection": "✘ Pʟᴜɢɪɴ : Detection\
\n\n⚡𝘾𝙈𝘿⚡: `.detect` <Reply/Username/ID>\
\n↳ : Melihat Riwayat Group Yang Pernah/Sedang Dimasuki."
})
| python |
"""https://de.dariah.eu/tatom/topic_model_python.html"""
import os
import numpy as np # a conventional alias
import sklearn.feature_extraction.text as text
from sklearn import decomposition
class TM_NMF:
def __init__(self, all_documents, num_topics, num_top_words, min_df, max_df, isblock):
self.all_documents = all_documents
self.num_topics = num_topics
self.num_top_words = num_top_words
self.min_df = min_df
self.max_df = max_df
path = os.getcwd() + '/' #'/IEami/'
#self.file = open(path + 'Topic_huge.txt', 'w')
if isblock:
self.file = open(path + 'result_ami/' + 'Topic_modeling_nmf_block_' + str(num_topics) + '_topics.txt', 'w')
else:
self.file = open(path + 'result_ami/' + 'Topic_modeling_nmf_' + str(num_topics) + '_topic_scenario.txt', 'w')
def find_NMF_topics(self):
"""
:param num_topics:
:param num_top_words: a list of top words for each topic
:return:
"""
vectorizer = text.CountVectorizer(input='filename', stop_words='english', min_df= self.min_df, max_df= self.max_df)
dtm = vectorizer.fit_transform(self.all_documents).toarray()
vocab = np.array(vectorizer.get_feature_names())
clf = decomposition.NMF(n_components = self.num_topics, random_state=1)
# it shows for how many proability each corpus is related to a word in topic results
self.doctopic = clf.fit_transform(dtm)
self.topic_words = []
for topic in clf.components_:
word_idx = np.argsort(topic)[::-1][0:self.num_top_words]
self.topic_words.append([vocab[i] for i in word_idx])
return
def show_corpus_vs_topics(self):
# ***************************************
self.file.write('******************************************************\n')
# they normaloze doctopic w.r.t its rows
doctopic = (self.doctopic) / (np.sum(self.doctopic, axis=1, keepdims=True))
corpus_names = []
for fn in self.all_documents:
name = os.path.basename(fn)
# name = name.rstrip('0123456789')
corpus_names.append(name)
# turn this into an array so we can use NumPy functions
novel_names = np.asarray(corpus_names)
doctopic_orig = doctopic.copy()
# use method described in preprocessing section
doctopic_grouped = np.zeros((len(corpus_names), self.num_topics))
# self.file.write('\t\t\t\t\t')
# for i in range(self.num_topics):
# self.file.write( 'topic'+ str(i+1) + '\t')
self.file.write('\n')
for i, name in enumerate(sorted(set(novel_names))):
tempo = np.mean(doctopic[novel_names == name, :], axis=0)
doctopic_grouped[i, :] = tempo
#self.file.write(name + " " + str(doctopic_grouped[i, :]) + '\n')
self.file.write('\n')
self.file.write("meetings\t\t\t\t\t")
self.file.write("top topics\t\t\t\t\t\t")
self.file.write("probabilities for top topics\n")
corpus = corpus_names
for i in range(len(doctopic)):
top_topics = np.argsort(doctopic[i, :])[::-1][0:5]
top_topics_str = ' '.join(str(t) for t in top_topics)
top_probabilities = ' '.join(str(doctopic[i][t]) for t in top_topics)
self.file.write("{}: {} {}".format(corpus[i], top_topics_str, top_probabilities) + '\n')
self.file.flush()
return
def show_topic_words(self):
self.file.write('\n')
for t in range(len(self.topic_words)):
self.file.write("Topic {}: {}".format(t, ' '.join(self.topic_words[t][:self.num_top_words]) + '\n'))
self.file.flush()
return
| python |
import RoothPath
import os
import re
import yaml
import json
if __name__ == '__main__':
yaml_dic = {}
with open(os.path.join(os.path.join(RoothPath.get_root(), 'Benchmarks'), 'den312d.map')) as ascii_map:
ascii_map.readline()
h = int(re.findall(r'\d+', ascii_map.readline())[0])
w = int(re.findall(r'\d+', ascii_map.readline())[0])
yaml_dic['agents'] = [{'start': [48, 10], 'name': 'agent0'}]
yaml_dic['map'] = {'dimensions': [w, h], 'obstacles': [], 'non_task_endpoints': [[48, 10]],
'start_locations': [[50, 10]], 'goal_locations': [[54, 10]]}
yaml_dic['n_tasks'] = 1
yaml_dic['task_freq'] = 1
yaml_dic['n_delays_per_agent'] = 10
ascii_map.readline()
for i in range(h - 1, -1, -1):
line = ascii_map.readline()
print(line)
for j in range(w):
if line[j] == '@' or line[j] == 'T':
yaml_dic['map']['obstacles'].append((j, i))
with open(os.path.join(RoothPath.get_root(), 'config.json'), 'r') as json_file:
config = json.load(json_file)
with open(os.path.join(os.path.join(RoothPath.get_root(), config['input_path']), 'dragon_age_map.yaml'), 'w') as param_file:
yaml.dump(yaml_dic, param_file)
| python |
# Copyright 2015, Ansible, Inc.
# Luke Sneeringer <[email protected]>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
from six.moves import StringIO
from tower_cli import models, resources, exceptions as exc
from tower_cli.api import client
from tower_cli.utils import debug
from tower_cli.constants import CUR_API_VERSION
from tests.compat import unittest, mock
class ResourceMetaTests(unittest.TestCase):
"""A set of tests to establish that the ResourceMeta metaclass works
in the way we expect.
"""
def test_commands(self):
"""Establish that commands are appropriately classified within
the resource, and that the stock commands are not present on a
BaseResource subclass.
"""
# Create the resource.
class MyResource(models.BaseResource):
endpoint = '/bogus/'
@resources.command
def foo(self):
pass
@resources.command
def bar(self):
pass
def boring_method(self):
pass
# Establish that the commands are present on the resource where
# we expect, and that the defined methods are still plain methods.
#
# Note: We can use something like types.FunctionType or
# types.UnboundMethodType to test against directly, but using a
# regular method is preferable because of differences between
# the type internals in Python 2 vs. Python 3.
#
# By just getting the desirable control type from another method
# on the resource, we are ensuring that it "just matches" regardless
# of which version of Python is in use.
self.assertIsInstance(MyResource.foo, type(MyResource.boring_method))
self.assertIsInstance(MyResource.bar, type(MyResource.boring_method))
self.assertEqual(set(MyResource.commands), set(['foo', 'bar', 'list', 'delete', 'get']))
def test_inherited_commands(self):
"""Establish that the stock commands are automatically present
on classes inherited from Resource.
"""
# Create the resource.
class MyResource(models.Resource):
endpoint = '/bogus/'
# Establish it has the commands we expect.
self.assertEqual(set(MyResource.commands),
set(['create', 'copy', 'modify', 'list', 'get',
'delete']))
def test_subclassed_commands(self):
"""Establish that commands overridden in subclasses retain their
superclass implementation options.
"""
# Create the subclass resource, overriding a superclass command.
class MyResource(models.Resource):
endpoint = '/bogus/'
@resources.command
def list(self, **kwargs):
return super(MyResource, self).list(**kwargs)
# Establish that it has one of the options added to the
# superclass list command.
self.assertEqual(MyResource.list.__click_params__, models.Resource.list.__click_params__)
def test_multiple_inheritance(self):
"""
Establish that click decoration from all parent class chains are
preserved in a subclass.
"""
class MyMixin(models.Resource):
endpoint = '/bogus/'
def list(self, **kwargs):
return super(MyMixin, self).list(**kwargs)
class MyResource(MyMixin, models.Resource):
endpoint = '/bogus/'
def list(self, **kwargs):
return super(MyResource, self).list(**kwargs)
self.assertTrue(hasattr(MyResource.list, '__click_params__'))
self.assertEqual(MyResource.list.__click_params__, models.Resource.list.__click_params__)
def test_no_duplicate_options_from_inheritance(self):
"""
Test that metaclass does not duplicate options from multiple parents
"""
class MyMixin1(models.Resource):
endpoint = '/bogus/'
class MyMixin2(models.Resource):
endpoint = '/boguser/'
class MyResource(MyMixin1, MyMixin2):
endpoint = '/boguser/'
def list(self, **kwargs):
return super(MyResource, self).list(**kwargs)
self.assertTrue(hasattr(MyResource.list, '__click_params__'))
self.assertEqual(MyResource.list.__click_params__, models.Resource.list.__click_params__)
def test_fields(self):
"""Establish that fields are appropriately classified within
the resource.
"""
# Create the resource.
class MyResource(models.Resource):
endpoint = '/bogus/'
foo = models.Field(unique=True)
bar = models.Field()
# Establish that our fields lists are the length we expect.
self.assertEqual(len(MyResource.fields), 2)
self.assertEqual(len(MyResource.unique_fields), 1)
# Establish that the fields are present in fields.
self.assertEqual(MyResource.fields[0].name, 'foo')
self.assertEqual(MyResource.fields[1].name, 'bar')
self.assertEqual(MyResource.unique_fields, set(['foo']))
def test_error_no_endpoint(self):
"""Establish that Resource subclasses are required to have
an endpoint, and attempting to create one that lacks an endpoint
raises TypeError.
"""
with self.assertRaises(TypeError):
class MyResource(models.Resource):
pass
def test_endpoint_normalization(self):
"""Establish that the endpoints have leading and trailing slashes
added if they are not present on a resource.
"""
class MyResource(models.Resource):
endpoint = 'foo'
self.assertEqual(MyResource.endpoint, '/foo/')
def test_disabled_property(self):
"""Establish that disabled_methods of derived classes disable specified
attributes derived from base classes.
"""
class MyRes(models.Resource):
endpoint = 'foo'
foobar = 'baz'
class MyDerivedRes(MyRes):
endpoint = 'bar'
disabled_methods = set(['foobar'])
res = MyDerivedRes()
with self.assertRaises(AttributeError):
getattr(res, 'foobar')
res.foobar = 'hey'
self.assertEqual(res.foobar, 'hey')
del res.foobar
with self.assertRaises(AttributeError):
getattr(res, 'foobar')
class ResourceTests(unittest.TestCase):
"""A set of tests to establish that the Resource class works in the
way that we expect.
"""
def setUp(self):
# Create a resource class that can be used across this particular
# suite.
class FooResource(models.Resource):
endpoint = '/foo/'
name = models.Field(unique=True)
description = models.Field(required=False)
self.res = FooResource()
def test_get(self):
"""Establish that the Resource class' `get` method works in the
way that we expect.
"""
with client.test_mode as t:
t.register_json('/foo/42/', {'id': 42, 'description': 'bar',
'name': 'foo'})
result = self.res.get(42)
self.assertEqual(result['id'], 42)
self.assertEqual(result['name'], 'foo')
def test_list_no_kwargs(self):
"""Establish that the Resource class' `list` method correctly
requests the resource and parses out a list of results.
"""
with client.test_mode as t:
t.register_json('/foo/', {'count': 2, 'results': [
{'id': 1, 'name': 'foo', 'description': 'bar'},
{'id': 2, 'name': 'spam', 'description': 'eggs'},
], 'next': None, 'previous': None})
result = self.res.list()
self.assertEqual(t.requests[0].url,
'https://20.12.4.21/api/%s/foo/' % CUR_API_VERSION)
self.assertEqual(result['count'], 2)
self.assertEqual(result['results'][0]['id'], 1)
def test_list_all_pages(self):
"""Establish that the Resource class' `list` method correctly
accepts the --all-pages flag and checks follow-up pages.
"""
with client.test_mode as t:
# Register the first, second, and third page.
t.register_json('/foo/', {'count': 3, 'results': [
{'id': 1, 'name': 'foo', 'description': 'bar'},
], 'next': '/foo/?page=2', 'previous': None})
t.register_json('/foo/?page=2', {'count': 3, 'results': [
{'id': 2, 'name': 'spam', 'description': 'eggs'},
], 'next': '/foo/?page=3', 'previous': None})
t.register_json('/foo/?page=3', {'count': 3, 'results': [
{'id': 3, 'name': 'bacon', 'description': 'cheese'},
], 'next': None, 'previous': None})
# Get the list
result = self.res.list(all_pages=True)
# Assert that there are three results, and three requests.
self.assertEqual(len(t.requests), 3)
self.assertEqual(len(result['results']), 3)
def test_list_with_page_1_special_case(self):
"""Establish that the list function works even if the server gives
/foo/ as the relative link for page 1.
"""
with client.test_mode as t:
# Register the 2nd page in order to test this.
t.register_json('/foo/?page=2', {'count': 2, 'results': [
{'id': 2, 'name': 'spam', 'description': 'eggs'},
], 'next': None, 'previous': '/foo/'})
# Get the list
result = self.res.list(page=2)
# Check that the function knows that /foo/ is page 1
self.assertEqual(result['previous'], 1)
def test_list_custom_kwargs(self):
"""Establish that if we pass custom keyword arguments to list, that
they are included in the final request.
"""
with client.test_mode as t:
t.register_json('/foo/?bar=baz', {'count': 0, 'results': [],
'next': None, 'previous': None})
self.res.list(query=[('bar', 'baz')])
self.assertTrue(t.requests[0].url.endswith('bar=baz'))
def test_get_unexpected_zero_results(self):
"""Establish that if a read method gets 0 results when it should have
gotten one or more, that it raises NotFound.
"""
with client.test_mode as t:
t.register_json('/foo/?name=spam', {'count': 0, 'results': []})
with self.assertRaises(exc.NotFound):
self.res.get(name='spam')
def test_get_no_debug_header(self):
"""Establish that if get is called with include_debug_header=False,
no debug header is issued.
"""
with mock.patch.object(type(self.res), 'read') as read:
with mock.patch.object(debug, 'log') as dlog:
read.return_value = {'results': [True]}
result = self.res.get(42, include_debug_header=False)
self.assertEqual(dlog.call_count, 0)
self.assertTrue(result)
def test_get_unexpected_multiple_results(self):
"""Establish that if a read method gets more than one result when
it should have gotten one and exactly one, that it raises
MultipleResults.
"""
# Register the response to the request URL.
# Note that this response should represent bad data, since name is
# generally unique within Tower. This doesn't matter for the purpose
# of this test; what's important is that if we expected one and exactly
# one result and we get two or more, that we complain in an expected
# (and later, handled) way.
with client.test_mode as t:
t.register_json('/foo/?name=spam', {'count': 2, 'results': [
{'id': 1, 'name': 'spam'},
{'id': 2, 'name': 'spam'},
], 'next': None, 'previous': None})
with self.assertRaises(exc.MultipleResults):
self.res.get(name='spam')
def test_list_with_none_kwargs(self):
"""Establish that if `list` is called with keyword arguments with
None values, that these are ignored.
This is to ensure that click's eagerness to send None values doesn't
cause problems.
"""
# Register the request and make the call.
with client.test_mode as t:
t.register_json('/foo/?name=foo', {'count': 1, 'results': [
{'id': 1, 'name': 'foo', 'description': 'bar'},
], 'next': None, 'previous': None})
self.res.list(name='foo', description=None)
self.assertEqual(len(t.requests), 1)
# Ensure that there are no other query param arguments other
# than `?name=foo` in the request URL.
self.assertNotIn('&', t.requests[0].url)
self.assertTrue(t.requests[0].url.endswith('?name=foo'))
def test_list_with_pagination(self):
"""Establish that the `list` method returns pages as integers
if it is given pages at all.
"""
with client.test_mode as t:
t.register_json('/foo/', {'count': 10, 'results': [
{'id': 1, 'name': 'bar'},
], 'next': '/api/%s/foo/?page=2' % CUR_API_VERSION, 'previous': None})
result = self.res.list()
self.assertEqual(result['next'], 2)
def test_reading_with_file(self):
"""Establish that if we get a file-like object, that it is
appropriately read.
"""
# Note: This is primarily for a case of longer input that belongs
# in files (such as SSH RSA/DSA private keys), but in this case we're
# using something trivial; we need only provide a proof of concept
# to test against.
sio = StringIO('bar')
with client.test_mode as t:
t.register_json('/foo/?name=bar', {'count': 0, 'results': [],
'next': None, 'previous': None})
self.res.list(name=sio)
self.assertTrue(t.requests[0].url.endswith('?name=bar'))
def test_create(self):
"""Establish that a standard create call works in the way that
we expect.
"""
with client.test_mode as t:
# `create` will attempt to see if the record already exists;
# mock this to state that it does not.
t.register_json('/foo/?name=bar', {'count': 0, 'results': [],
'next': None, 'previous': None})
t.register_json('/foo/', {'changed': True, 'id': 42},
method='POST')
self.res.create(name='bar')
self.assertEqual(t.requests[0].method, 'GET')
self.assertEqual(t.requests[1].method, 'POST')
def test_create_already_existing(self):
"""Establish that if we attempt to create a record that already exists,
that no action ends up being taken.
"""
with client.test_mode as t:
t.register_json('/foo/?name=bar', {'count': 1, 'results': [
{'id': 42, 'name': 'bar'},
], 'next': None, 'previous': None})
result = self.res.create(name='bar')
self.assertEqual(len(t.requests), 1)
self.assertFalse(result['changed'])
def test_create_missing_required_fields(self):
"""Establish that if we attempt to create a record and don't specify
all required fields, that we raise BadRequest.
"""
# Create a resource with a required field that isn't the name
# field.
class BarResource(models.Resource):
endpoint = '/bar/'
name = models.Field(unique=True)
required = models.Field()
res = BarResource()
# Attempt to write the resource and prove that it fails.
with client.test_mode as t:
t.register_json('/bar/?name=foo', {'count': 0, 'results': [],
'next': None, 'previous': None})
with self.assertRaises(exc.BadRequest):
res.create(name='foo')
def test_modify(self):
"""Establish that the modify method works in the way we expect,
given a normal circumstance.
"""
with client.test_mode as t:
t.register_json('/foo/42/', {'id': 42, 'name': 'bar',
'description': 'baz'})
t.register_json('/foo/42/',
{'changed': True, 'id': 42}, method='PATCH')
result = self.res.modify(42, description='spam')
self.assertTrue(result['changed'])
self.assertEqual(t.requests[1].body, '{"description": "spam"}')
def test_modify_no_changes(self):
"""Establish that the modify method does not actually attempt
a modification if there are no changes.
"""
with client.test_mode as t:
t.register_json('/foo/42/', {'id': 42, 'name': 'bar',
'description': 'baz'})
result = self.res.modify(42, description='baz')
self.assertFalse(result['changed'])
self.assertEqual(len(t.requests), 1)
def test_modify_ignore_kwargs_none(self):
"""Establish that we ignore keyword arguments set to None when
performing writes.
"""
with client.test_mode as t:
t.register_json('/foo/42/', {'id': 42, 'name': 'bar',
'description': 'baz'})
result = self.res.modify(42, name=None, description='baz')
self.assertFalse(result['changed'])
self.assertEqual(len(t.requests), 1)
self.assertNotIn('name', t.requests[0].url)
def test_write_file_like_object(self):
"""Establish that our write method, if it gets a file-like object,
correctly reads it and uses the file's value as what it sends.
"""
sio = StringIO('bar')
with client.test_mode as t:
t.register_json('/foo/?name=bar', {'count': 1, 'results': [
{'id': 42, 'name': 'bar', 'description': 'baz'},
], 'next': None, 'previous': None})
result = self.res.modify(name=sio, description='baz')
self.assertFalse(result['changed'])
self.assertIn('name=bar', t.requests[0].url)
def test_write_with_null_field(self):
"""Establish that a resource with 'null' field is written."""
with client.test_mode as t:
t.register_json('/foo/42/', {'id': 42, 'name': 'bar',
'description': 'baz'}, method='GET')
t.register_json('/foo/42/', {'name': 'bar', 'id': 42,
'inventory': 'null'}, method='PATCH')
self.res.write(42, inventory='null')
self.assertEqual(json.loads(t.requests[1].body)['inventory'], None)
def test_delete_with_pk(self):
"""Establish that calling `delete` and providing a primary key
works in the way that we expect.
"""
with client.test_mode as t:
t.register('/foo/42/', '', method='DELETE')
result = self.res.delete(42)
self.assertTrue(result['changed'])
def test_delete_without_pk(self):
"""Establish that calling `delete` with keyword arguments works
in the way that we expect.
"""
with client.test_mode as t:
t.register_json('/foo/?name=bar', {'count': 1, 'results': [
{'id': 42, 'name': 'bar', 'description': 'baz'},
], 'next': None, 'previous': None})
t.register('/foo/42/', '', method='DELETE')
result = self.res.delete(name='bar')
self.assertEqual(len(t.requests), 2)
self.assertTrue(t.requests[1].url.endswith('/foo/42/'))
self.assertTrue(result['changed'])
def test_delete_with_pk_already_missing(self):
"""Establish that calling `delete` on a record that does not exist
returns back an unchanged response.
"""
with client.test_mode as t:
t.register_json('/foo/42/', '', method='DELETE', status_code=404)
result = self.res.delete(42)
self.assertFalse(result['changed'])
def test_delete_with_pk_already_missing_exc(self):
"""Establish that calling `delete` on a record that does not
exist raises an exception if requested.
"""
with client.test_mode as t:
t.register_json('/foo/42/', '', method='DELETE', status_code=404)
with self.assertRaises(exc.NotFound):
self.res.delete(42, fail_on_missing=True)
def test_delete_without_pk_already_missing(self):
"""Establish that calling `delete` on a record without a primary
key correctly sends back an unchanged response.
"""
with client.test_mode as t:
t.register_json('/foo/?name=bar', {'count': 0, 'results': []})
result = self.res.delete(name='bar')
self.assertFalse(result['changed'])
def test_delete_without_pk_already_missing_exc(self):
"""Establish that calling `delete` on a record without a primary
key correctly sends back an unchanged response.
"""
with client.test_mode as t:
t.register_json('/foo/?name=bar', {'count': 0, 'results': []})
with self.assertRaises(exc.NotFound):
self.res.delete(name='bar', fail_on_missing=True)
def test_assoc_already_present(self):
"""Establish that the _assoc method returns an unchanged status
message if it attempts to associate two records that are already
associated.
"""
with client.test_mode as t:
t.register_json('/foo/42/bar/?id=84', {'count': 1, 'results': [
{'id': 84},
], 'next': None, 'previous': None})
result = self.res._assoc('bar', 42, 84)
self.assertFalse(result['changed'])
def test_assoc_not_already_present(self):
"""Establish that the _assoc method returns an changed status
message and associates objects if appropriate.
"""
with client.test_mode as t:
t.register_json('/foo/42/bar/?id=84', {'count': 0, 'results': []})
t.register_json('/foo/42/bar/', {}, method='POST')
result = self.res._assoc('bar', 42, 84)
self.assertEqual(json.loads(t.requests[1].body),
{'associate': True, 'id': 84})
self.assertTrue(result['changed'])
def test_disassoc_not_already_present(self):
"""Establish that the _disassoc method returns an unchanged status
message if it attempts to associate two records that are not
associated.
"""
with client.test_mode as t:
t.register_json('/foo/42/bar/?id=84', {'count': 0, 'results': []})
result = self.res._disassoc('bar', 42, 84)
self.assertFalse(result['changed'])
def test_disassoc_already_present(self):
"""Establish that the _assoc method returns an changed status
message and associates objects if appropriate.
"""
with client.test_mode as t:
t.register_json('/foo/42/bar/?id=84', {'count': 1, 'results': [
{'id': 84},
], 'next': None, 'previous': None})
t.register_json('/foo/42/bar/', {}, method='POST')
result = self.res._disassoc('bar', 42, 84)
self.assertEqual(json.loads(t.requests[1].body),
{'disassociate': True, 'id': 84})
self.assertTrue(result['changed'])
def test_lookup_with_unique_field_not_present(self):
"""Establish that a if _lookup is invoked without any unique
field specified, that BadRequest is raised.
"""
with client.test_mode:
with self.assertRaises(exc.BadRequest):
self.res._lookup(description='abcd')
def test_lookup_errant_found(self):
"""Establish that if _lookup is invoked and finds a record when it
should not, that an appropriate exception is raised.
"""
with client.test_mode as t:
t.register_json('/foo/?name=bar', {'count': 1, 'results': [
{'id': 42, 'name': 'bar'},
], 'next': None, 'previous': None})
with self.assertRaises(exc.Found):
self.res._lookup(name='bar', fail_on_found=True)
def test_copy_with_multiples(self):
"""
A resource with fields marked `multiple` has those fields copied fully
"""
class BarResource(models.Resource):
endpoint = '/bar/'
name = models.Field(unique=True)
variables = models.Field(multiple=True)
res = BarResource()
with mock.patch.object(res, 'read') as read_mock:
read_mock.return_value = {
"count": 1,
"results": [
{
"id": 42,
"name": "foobarin",
"variables": "foobar: barfood"
}
]
}
with mock.patch.object(res, 'write') as write_mock:
res.copy()
name, args, kwargs = write_mock.mock_calls[0]
self.assertEqual(kwargs['name'][:len("foobarin")], "foobarin")
self.assertEqual(kwargs['variables'], ('foobar: barfood',))
self.assertNotIn('id', kwargs)
class MonitorableResourcesTests(unittest.TestCase):
"""Estblaish that the MonitorableResource abstract class works in the
way that we expect.
"""
def test_status_not_implemented(self):
"""Establish that the abstract MonitorableResource's status
method raises NotImplementedError.
"""
with self.assertRaises(NotImplementedError):
models.MonitorableResource().status(None)
class SurveyResourceTests(unittest.TestCase):
"""Test methods specific to survey models."""
def setUp(self):
self.res = models.SurveyResource()
self.res.endpoint = '/job_templates/'
def test_survey_no_op(self):
with mock.patch.object(models.base.BaseResource, 'write') as w:
self.res.modify(name='foobar')
w.assert_called_once_with(
create_on_missing=False, force_on_exists=True,
name='foobar', pk=None)
def test_survey_create(self):
with mock.patch.object(models.base.BaseResource, 'write') as w:
w.return_value = {'id': 42, 'survey_enabled': True}
survey_data = {'foobar': 'foo'}
with client.test_mode as t:
t.register_json(
'/job_templates/42/survey_spec/', {},
method='POST'
)
self.res.modify(survey_spec=survey_data, verbose=True)
self.assertEqual(t.requests[0].body, json.dumps(survey_data))
def test_survey_delete(self):
with mock.patch.object(models.base.BaseResource, 'write') as w:
w.return_value = {'id': 42, 'survey_enabled': True}
with client.test_mode as t:
t.register_json(
'/job_templates/42/survey_spec/', {},
method='DELETE'
)
self.res.modify(survey_spec={}, verbose=True)
self.assertEqual(t.requests[0].method, 'DELETE')
| python |
# -*- coding: utf-8 -*-
import json
from typing import Iterable
from pyrus_nn.rust.pyrus_nn import PyrusSequential
from pyrus_nn import layers
class Sequential:
# This is the actual Rust implementation with Python interface
_model: PyrusSequential
def __init__(self, lr: float, n_epochs: int, batch_size: int = 32, cost_func: str = "mse"):
"""
Initialize the model.
Parameters
----------
lr: float
The learning rate of the model
n_epochs: int
How many epochs shall it do for training
"""
self._model = PyrusSequential(lr, n_epochs, batch_size, cost_func)
self.lr = lr
self.n_epochs = n_epochs
self.batch_size = batch_size
self.cost_func = cost_func
def fit(self, X: Iterable[Iterable[float]], y: Iterable[Iterable[float]]):
"""
Fit the model using X and y. Each of which would be a 2d iterable.
For example::
X = [[1, 2, 3], [4, 5, 6]]
y = [[1], [2]]
Parameters
----------
X: Iterable
2d iterable
y: Iterable
2d iterable
Returns
-------
self
"""
self._model.fit(X, y)
return self
def predict(self, X: Iterable[Iterable[float]]) -> Iterable[Iterable[float]]:
"""
Apply the model to input data
Parameters
----------
X: Iterable
2d iterable
Returns
-------
Iterable[Iterable[float]]
"""
return self._model.predict(X)
def add(self, layer: layers.Layer):
"""
Add a layer to this network
Parameters
----------
layer: pyrus_nn.layers.Layer
A layer compatible with the previous layer
Returns
-------
None
"""
if isinstance(layer, layers.Dense):
self._model.add_dense(layer.n_input, layer.n_output, layer.activation)
def to_dict(self):
"""
Serialize this network as a dictionary of primitives suitable
for further serialization into json, yaml, etc.
Returns
-------
dict
"""
return dict(
params=self.get_params(),
model=json.loads(self._model.to_json())
)
@classmethod
def from_dict(cls, conf: dict):
"""
Re-construct the model from a serialized version of itself
Parameters
----------
conf: dict
Configuration resulting from a previous call to ``.to_dict()``
Returns
-------
Sequential
"""
model = cls(**conf['params'])
model._model = PyrusSequential.from_json(json.dumps(conf['model']))
return model
def get_params(self, deep=False):
return dict(
lr=self.lr,
n_epochs=self.n_epochs
)
def __eq__(self, other: "Sequential"):
return other.to_dict() == self.to_dict()
| python |
from django import template
from cart.utils import get_or_set_order_session
register = template.Library()
@register.filter
def cart_item_count(request):
order = get_or_set_order_session(request)
count = order.items.count()
return count
| python |
from visions.utils.monkeypatches import imghdr_patch, pathlib_patch
__all__ = [
"imghdr_patch",
"pathlib_patch",
]
| python |
from pprint import pprint
from ayesaac.services.common import QueueManager
from ayesaac.utils.logger import get_logger
logger = get_logger(__file__)
class Interpreter(object):
"""
The Interpreter class purpose is a simple comparison with what the vision part find
and what the user asked for.
(Which object was found and not found)
"""
def __init__(self):
self.queue_manager = QueueManager(
[self.__class__.__name__, "NaturalLanguageGenerator"]
)
self.memory = {}
logger.info(f"{self.__class__.__name__} ready")
def filter_objects(self, body):
return body["objects"]
def filter_texts(self, body):
return body["texts"]
def callback(self, body, **_):
data = None
key = ""
if "objects" in body:
key = "objects"
data = self.filter_objects(body)
body["objects"] = data
elif "texts" in body:
key = "texts"
data = self.filter_texts(body)
body["texts"] = data
if body["wait_package"] == 1:
body["path_done"].append(self.__class__.__name__)
del body["vision_path"]
# pprint(body)
# TODO: uncomment if you wanna test the NLG, it could be text, objects,
# objects + colour, objects + lateral position
self.queue_manager.publish("NaturalLanguageGenerator", body)
else:
if body["intern_token"] not in self.memory:
self.memory[body["intern_token"]] = {key: data}
elif (
body["intern_token"] in self.memory
and body["wait_package"] < len(self.memory[body["intern_token"]]) - 1
):
self.memory[body["intern_token"]][key] = data
else:
for key in self.memory[body["intern_token"]]:
body[key] = self.memory[body["intern_token"]][key]
del self.memory[body["intern_token"]][key]
# pprint(body)
# TODO: uncomment if you wanna test the NLG
self.queue_manager.publish("NaturalLanguageGenerator", body)
def run(self):
self.queue_manager.start_consuming(self.__class__.__name__, self.callback)
def main():
interpreter = Interpreter()
interpreter.run()
if __name__ == "__main__":
main()
| python |
from core.models import MedicalCare, Pets, Tutor, Vet
from django.contrib import admin
admin.site.register(Vet)
class MedicalCareAdmin(admin.ModelAdmin):
list_display = ('id', 'date', 'time', 'pet_name', 'procedure', 'report')
admin.site.register(MedicalCare, MedicalCareAdmin)
class PetsAdmin(admin.ModelAdmin):
list_display = ('id', 'pet_name', 'species', 'breed',
'gender', 'date_of_birth', 'castrated', 'weight')
admin.site.register(Pets, PetsAdmin)
class TutorAdmin(admin.ModelAdmin):
list_display = ('tutor_name', 'cpf', 'phone', 'email',
'street', 'number', 'district', 'state', 'cep')
admin.site.register(Tutor, TutorAdmin)
| python |
#Test Array Implementation
import os
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from pyds import array
#test array
print("01 : ======= Creating Array of size 5 =======")
arr = array(5)
print("02: ======= Traversing Array =======")
arr.print()
print("03: ======= Insert 5 Items =======")
arr.insert(0,1)
arr.insert(1,2)
arr.insert(2,3)
arr.insert(3,4)
arr.insert(4,5)
print("======= Traversing Array =======")
arr.print()
print("04: ======= Exceeding Items =======")
try:
arr.insert(5,6)
except Exception as err:
print(err)
print("05: ======= Delete Item at index 0 =======")
print(arr.delete(0))
print("06: ======= Re-Traversing Array =======")
arr.print()
| python |
import json
import time
import logging
import requests
import functools
class WechatAppPush:
"""
WechatAppPush decorator
Push the msg of the decorated function
Example 1:
@WechatAppPush(corpid, corpsecret, agentid)
def func():
return 'xxx'
Example 2:
def func():
return 'xxx'
WechatAppPush(corpid, corpsecret, agentid)(func())()
Example 3:
WechatAppPush(corpid, corpsecret, agentid)('xxx')()
Then wechat app will push xxx
:param corpid: wechat app corpid
:param corpsecret: wechat app corpsecret
:param agentid: wechat app agentid
:param touser: wechat app @ touser (optional, default: @all )
:param message: wechat push message (optional, default: Wechat push message tset)
:return func:
docs: https://developer.work.weixin.qq.com/document/path/90236
"""
def __init__(self, corpid: str, corpsecret: str, agentid: str, touser: str = '@all', message: str = 'Wechat push message tset') -> None:
self._corpid = corpid
self._corpsecret = corpsecret
self._agentid = agentid
self._touser = touser
self._message = message
def __call__(self, func=None):
@functools.wraps(func)
def wrapper(*args, **kwargs):
# before func
try:
self._message = func(*args, **kwargs)
except:
if func != None:
self._message = func
# after func
response = self.send_text()
if response != "ok":
print(f'Wechat push error: {response}')
return self._message
return wrapper
def get_access_token(self) -> str:
send_url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken"
send_values = {
"corpid": self._corpid,
"corpsecret": self._corpsecret,
}
response = requests.post(send_url, params=send_values).json()
return response["access_token"]
def send_text(self) -> str:
send_url = (
"https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token="
+ self.get_access_token()
)
send_values = {
"touser": self._touser,
"msgtype": "text",
"agentid": self._agentid,
"text": {"content": self._message},
"safe": "0",
}
send_msges = bytes(json.dumps(send_values), "utf-8")
respone = requests.post(send_url, send_msges)
respone = respone.json()
return respone["errmsg"]
class Debug:
"""
Debug decorator
:param level:
:param func_time:
:param func_info:
"""
def __init__(self, level=logging.DEBUG, func_time=True, func_info=True) -> None:
self._func_timer = func_time
self._level = level
self._func_info = func_info
LOG_FORMAT = "%(asctime)s - %(levelname)s - %(message)s"
DATE_FORMAT = "%m/%d/%Y %H:%M:%S %p"
logging.basicConfig(level=self._level, format=LOG_FORMAT, datefmt=DATE_FORMAT)
def __call__(self, func):
@self.func_time
@self.func_info
@functools.wraps(func)
def wrapper(*args, **kwargs):
value = func(*args, **kwargs)
return value
return wrapper
def func_time(self, func):
"""Print the runtime of the decorated function"""
if self._func_timer != True:
return func
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.perf_counter()
# before func
value = func(*args, **kwargs)
# after func
end_time = time.perf_counter()
run_time = end_time - start_time
logging.log(msg=f"Finished {func.__name__!r} in {run_time:.4f} secs", level=self._level)
return value
return wrapper
def func_info(self, func):
"""Print the function signature and return value"""
if self._func_info != True:
return func
@functools.wraps(func)
def wrapper(*args, **kwargs):
args_repr = [repr(a) for a in args]
kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
signature = ", ".join(args_repr + kwargs_repr)
logging.log(msg=f"Calling {func.__name__}({signature})", level=self._level)
# before func
value = func(*args, **kwargs)
# after func
logging.log(msg=f"{func.__name__!r} returned {value!r}", level=self._level)
return value
return wrapper
| python |
N = int(input())
print(f'{((N + 1) // 2 / N):.10f}') | python |
try:
from datetime import datetime
import pandas as pd
import numpy as np
from pathlib import Path
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
from sklearn.linear_model import BayesianRidge
from sklearn import preprocessing
except:
pass
from environmental_data_modules import PostProcessor, AurnModule, DateRangeProcessor
class AurnPostProcessor(PostProcessor, AurnModule, DateRangeProcessor):
"""
Class used for post-processing data that has been extracted from AURN server.
"""
# Define 'absolute' constants
BASE_FILE_OUT = '{}/aurn_processed_daily_{}.csv'
# Define default constants
DEFAULT_OUT_DIR = 'Aurn_processed_data'
DEFAULT_EMEP_FILENAME = None
# Calculation defaults
DEFAULT_MIN_YEARS_REFERENCE = 1
DEFAULT_MIN_YEARS = 1
DEFAULT_IMPUTER_RANDOM_STATE = 0
DEFAULT_IMPUTER_ADD_INDICATOR = False
DEFAULT_IMPUTER_INITIAL_STRATEGY = 'mean'
DEFAULT_IMPUTER_MAX_ITER = 100
try:
DEFAULT_IMPUTER_ESTIMATOR = BayesianRidge()
except:
DEFAULT_IMPUTER_ESTIMATOR = None
DEFAULT_TRANSFORMER_OUTPUT_DISTRIBUTION = 'normal'
DEFAULT_TRANSFORMER_METHOD = 'box-cox'
DEFAULT_TRANSFORMER_STANDARDIZE = False
def __init__(self, metadata_filename=AurnModule.DEFAULT_METADATA_FILE, metadata_url=AurnModule.DEFAULT_METADATA_URL,
out_dir=DEFAULT_OUT_DIR, verbose=PostProcessor.DEFAULT_VERBOSE):
""" Initialise instance of the AurnPostProcessor class.
Initialises the private class variables
Args:
metadata_filename: filename of the metadata used in Aurn data extraction
metadata_url: alternative source of AURN metadata, if metadata_filename is None
out_dir: (string) directory to be used for all outputs
verbose: (integer) level of verbosity in output.
Returns:
Initialised instance of AurnPostProcessor
"""
super(AurnPostProcessor, self).__init__(out_dir, verbose)
AurnModule.__init__(self, metadata_filename=metadata_filename, metadata_url=metadata_url)
DateRangeProcessor.__init__(self)
self._emep_data = None
self.min_years_reference = AurnPostProcessor.DEFAULT_MIN_YEARS_REFERENCE
self.min_years = AurnPostProcessor.DEFAULT_MIN_YEARS
self.impute_data = False
self._imputer = None
self._transformer = None
@PostProcessor.transformer.setter
def transformer(self, transformer):
if transformer is None or type(transformer).__name__ in ['QuantileTransformer','PowerTransformer']:
self._transformer = transformer
else:
raise ValueError('Error setting transformer, incorrect object type: {}'.format(type(transformer).__name__))
@PostProcessor.station_data.setter
def station_data(self, raw_data):
if self.verbose > 0:
print('Loading stations data metadata')
try:
station_data = raw_data.drop_duplicates()
station_data = station_data.set_index('site_id')
except Exception as err:
raise ValueError('Unable to get correct site data from Metadata input file. Check metadata file content.')
self._station_data = station_data
def impute_method_setup(self, random_state=DEFAULT_IMPUTER_RANDOM_STATE, add_indicator=DEFAULT_IMPUTER_ADD_INDICATOR,
initial_strategy=DEFAULT_IMPUTER_INITIAL_STRATEGY,
max_iter=DEFAULT_IMPUTER_MAX_ITER, estimator=DEFAULT_IMPUTER_ESTIMATOR,
output_distribution=DEFAULT_TRANSFORMER_OUTPUT_DISTRIBUTION,
transformer_method=DEFAULT_TRANSFORMER_METHOD, transformer_standardize=DEFAULT_TRANSFORMER_STANDARDIZE):
""" Initialises the IterativeImputer, QuantileTransformer and PowerTransformer methods required
if missing data is to be imputed.
Parameters are passed to the sklearn routines. Where this is being done it is noted below.
For further documentation on how these functions work, and what the parameters denote,
please refer to the sklearn documentation.
IterativeImputer: https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html
QuantileTransformer: https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.QuantileTransformer.html
PowerTransformer: https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PowerTransformer.html
Args:
random_state: (int) (IterativeImputer & QuantileTransformer) seed for pseudo random number generator
add_indicator: (boolean) (IterativeImputer) if True adds a `MissingIndicator` transform to the stack
initial_strategy: (str) (IterativeImputer) define strategy to use for initialising missing values
max_iter: (int) (IterativeImputer) maximum number of imputation rounds to perform
estimator: (str) (IterativeImputer) estimator method to be used
output_distribution: (str) (QuantileTransformer) Marginal distribution for the transformed data
transformer_method (str) (PowerTransformer) method to use, 'box-cox' is default
transformer_standardize (boolean) (PowerTransformer) select if zero-mean, unit-variance normalisation is applied, default is True
Returns: None
"""
# set the imputer options (if we are using them)
self.imputer = IterativeImputer(random_state=random_state, add_indicator=add_indicator,
initial_strategy=initial_strategy, max_iter=max_iter, verbose=self.verbose,
estimator=estimator)
# set the power transform options
self.transformer_quantile = preprocessing.QuantileTransformer(output_distribution=output_distribution,
random_state=random_state)
# set the power transform options
self.transformer_power = preprocessing.PowerTransformer(method=transformer_method,
standardize=transformer_standardize)
def process(self, in_file, date_range=None,
site_list=AurnModule.DEFAULT_SITE_LIST,
emep_filename=DEFAULT_EMEP_FILENAME,
min_years_reference=DEFAULT_MIN_YEARS_REFERENCE,
min_years=DEFAULT_MIN_YEARS,
impute_data=PostProcessor.DEFAULT_IMPUTE_DATA,
save_to_csv=PostProcessor.DEFAULT_SAVE_TO_CSV,
outfile_suffix='',
species_list=AurnModule.SPECIES_LIST_EXTRACTED):
""" Post process the data extracted from the AURN dataset, based on the parameters given.
Args:
in_file: (str) The file spec of the input file (required)
date_range: (list of 2 datetime) The date range of interest
site_list: (list of string/number) Site IDs of interest
emep_filename: (str) The file spec of the EMEP file to be used to help calculate #Todo Doug
min_years_reference: (float) The minimum number of years of data for any site that we are going to
use as a reference site later. (this cannot be less than min_years)
min_years: (float) The minimum number of years of data that a site must have
impute_data: (boolean) Whether to attempt to impute missing data
save_to_csv: (boolean) Whether to save the output dateframes to CSV file(s)
outfile_suffix: (str) The suffix to appended to the end of output file names.
Returns:
daily_dataframe: daily dataset, for all measurements, as pandas.Dataframe
Required MultiIndex:
'time_stamp' (datetime object): date (only) (e.g. 2017-06-01)
'sensor_name' (string): ID string for site (e.g. 'LIN3 [AQ]')
Required columns:
'O3.max' (float): daily maximum value
'O3.mean' (float): daily mean value
'O3.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'PM10.max' (float): daily maximum value
'PM10.mean' (float): daily mean value
'PM10.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'PM2.5.max' (float): daily maximum value
'PM2.5.mean' (float): daily mean value
'PM2.5.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'NO2.max' (float): daily maximum value
'NO2.mean' (float): daily mean value
'NO2.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'NOXasNO2.max' (float): daily maximum value
'NOXasNO2.mean' (float): daily mean value
'NOXasNO2.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'SO2.max' (float): daily maximum value
'SO2.mean' (float): daily mean value
'SO2.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
"""
if not isinstance(in_file, str):
raise ValueError('in_file must be a string')
# Process inputs
if date_range is not None:
self.date_range = [datetime.strptime(date_range[0], DateRangeProcessor.INPUT_DATE_FORMAT),
datetime.strptime(date_range[1], DateRangeProcessor.INPUT_DATE_FORMAT)]
else:
self.date_range = [self.get_available_start(), self.get_available_end()]
self.file_out = AurnPostProcessor.BASE_FILE_OUT.format(self.out_dir, outfile_suffix)
self._emep_data = self.load_emep_data(emep_filename)
self.min_years = min_years
self.min_years_reference = min_years_reference
self.species_list = species_list
self.site_list = site_list
self.station_data = self.metadata['AURN_metadata'][['site_id', 'latitude', 'longitude', 'site_name']]
if self.verbose > 1: print('Station data: \n {}'.format(self.station_data))
self.impute_data = impute_data
# load and prepare the hourly dataset
hourly_dataframe = self.load_aurn_data(in_file)
print('filter for minimum data lengths, and reduce dataset to only stations of interest')
hourly_dataframe_filtered, reference_sites, required_sites, site_list_internal = \
self.list_required_and_reference_sites(hourly_dataframe)
# get the list of required sites from what is available, and what was requested
site_list_internal = set(site_list_internal).intersection(self.site_list)
if len(hourly_dataframe_filtered.index) == 0:
print('Exiting post-processing: Metadata is empty after initial filtering processes')
return
if self.impute_data:
print('imputation of data, returning hourly data')
hourly_dataframe = self.organise_data_imputation(
hourly_dataframe_filtered, reference_sites, required_sites, site_list_internal)
else:
print('sorting data (no imputation), returning hourly data')
hourly_dataframe = self.organise_data(hourly_dataframe_filtered, site_list_internal)
# calculate the daily max and mean for each station
daily_dataframe = self.combine_and_organise_mean_max(hourly_dataframe)
if save_to_csv:
# write this dataset to file
daily_dataframe.to_csv(self.file_out, index=True, header=True, float_format='%.2f')
return daily_dataframe
def combine_and_organise_mean_max(self, hourly_dataframe):
"""
Combine and organise the daily mean, maximum, and count information.
Args:
hourly_dataframe: hourly dataset, for all measurements, as pandas.Dataframe
Required Index:
timestamp (datetime object):
site_id (string):
Optional Columns:
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
imputed O3 (int): flag indicating imputed data (0=original,1=imputed)
imputed PM10 (int):
imputed PM2.5 (int):
imputed NO2 (int):
imputed NOXasNO2 (int):
imputed SO2 (int):
Returns:
final_dataframe: daily dataset, for all measurements, as pandas.Dataframe
Required MultiIndex:
'time_stamp' (datetime object): date (only) (e.g. 2017-06-01)
'sensor_name' (string): ID string for site (e.g. 'LIN3 [AQ]')
Required columns:
'O3.max' (float): daily maximum value
'O3.mean' (float): daily mean value
'O3.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'PM10.max' (float): daily maximum value
'PM10.mean' (float): daily mean value
'PM10.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'PM2.5.max' (float): daily maximum value
'PM2.5.mean' (float): daily mean value
'PM2.5.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'NO2.max' (float): daily maximum value
'NO2.mean' (float): daily mean value
'NO2.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'NOXasNO2.max' (float): daily maximum value
'NOXasNO2.mean' (float): daily mean value
'NOXasNO2.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
'SO2.max' (float): daily maximum value
'SO2.mean' (float): daily mean value
'SO2.flag' (float): flag to indicate fraction of imputed data
(1 = fully imputed, 0 = no imputed values were used)
"""
#### group by date and site
daily_grouped_data = hourly_dataframe.groupby([pd.Grouper(level=self._timestamp_string, freq='1D'), self._site_string])
spc_list = self.species_list
#### loop by spc through grouped data, and calculate the mean, max, and flag values
for spc in spc_list:
temp_dataframe = pd.DataFrame()
temp_dataframe['{}_mean'.format(spc)] = daily_grouped_data.mean()[spc]
temp_dataframe['{}_max'.format(spc)] = daily_grouped_data.max()[spc]
temp_dataframe['{}_flag'.format(spc)] = daily_grouped_data.mean()['{}_flag'.format(spc)]
try:
final_dataframe = final_dataframe.merge(temp_dataframe, how='outer', left_index=True, right_index=True)
except:
final_dataframe = temp_dataframe.copy()
#### rename the sites, to include AQ flag
final_dataframe.index = final_dataframe.index.set_levels(
['{} [AQ]'.format(x) for x in final_dataframe.index.levels[1]], level=1)
#### return output dataframe
return(final_dataframe)
def load_aurn_data(self, file_in):
"""
Loading the AURN dataset.
Args:
file_in (Path object or string): path for the file to be read in
Returns:
hourly_dataframe: hourly dataset, for all measurements, as pandas.Dataframe
Index: none
Required Columns:
timestamp (datetime object):
site_id (string):
Optional Columns:
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
"""
# Read in hourly dataframe file
try:
hourly_dataframe = pd.read_csv(file_in,
sep=',',
usecols=[AurnModule.INDEX_EXTRACTED].append(AurnModule.NEW_FILE_COLS),
index_col=AurnModule.INDEX_EXTRACTED,
parse_dates=[self._timestamp_string])
except Exception as err:
raise ValueError('Unable to read Met extracted data file {}. {}'.format(file_in, err))
if self.verbose > 1:
print('Hourly dataframe: \n {}'.format(hourly_dataframe))
print('Hourly dataframe data types: \n {}'.format(hourly_dataframe.dtypes))
return(hourly_dataframe)
def load_emep_data(self, filename):
"""
Loads the EMEP model data, or create an empty dataframe (required for logic checks in the workflow)
Args:
filename (str): location of the EMEP file. This should be empty if there is no EMEP data
Returns:
emep_dataframe: pandas Dataframe, containing the EMEP model data. If no EMEP data
is to be used then this will be an empty Dataframe.
Index: none
Required Columns:
timestamp (datetime object):
site_id (string):
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
"""
if filename is not None:
filename = Path(filename)
print('reading emep file')
try:
emep_dataframe = pd.read_csv(filename)
except Exception as err:
raise ValueError('Error loading the emap data from filename: {} . {}'.format(filename, err))
try:
return emep_dataframe.rename(columns={'NOx': 'NOXasNO2'})
except Exception as err:
raise ValueError('EMEP file does not contain an \'NOx\' column')
else:
return pd.DataFrame()
def list_required_and_reference_sites(self, data_in):
"""
This function creates the lists of required sites, and reference sites, for the
final dataset.
Args:
data_in: hourly dataset, for all measurements, as pandas.Dataframe
Index: none
Required Columns:
timestamp (datetime object):
site_id (string):
Optional Columns:
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
Returns:
met_data_filtered: pandas dataframe, as above, containing hourly dataset for only
the required station datasets
reference_sites: (dict, keys are species):
items: (list of strings) the site_id's for our reference sites for each `spc`
required_sites: (dict, keys are species):
items: (list of strings) required sites for `spc`
combined_req_site_list: (list, strings) a single list of required sites
"""
print(' get the lists of required and reference stations for each measurement variable')
tempgroups = data_in.groupby([self._site_string, pd.Grouper(key=self._timestamp_string, freq='1D')])
daily_hour_counts = tempgroups.count()
spc_list = daily_hour_counts.columns.values
required_sites = {}
reference_sites = {}
combined_req_site_list = []
for spc in spc_list:
print('site day counts for {}'.format(spc))
req_days_counts = daily_hour_counts[spc]
req_days_counts = req_days_counts[req_days_counts > 0]
required_sites[spc], reference_sites[spc] = self.station_listing(req_days_counts)
combined_req_site_list = combined_req_site_list + required_sites[spc]
print('VERBOSE: ', self.verbose)
if self.verbose > 0: print('\t\treq sites {}:'.format(spc), required_sites[spc])
if self.verbose > 0: print('\t\tuse sites {}:'.format(spc), reference_sites[spc])
# get a list of all sites which are required for at least one measurement set
combined_req_site_list = list(dict.fromkeys(combined_req_site_list))
data_filtered = data_in[data_in[self._site_string].isin(combined_req_site_list)]
return data_filtered, reference_sites, required_sites, combined_req_site_list
def organise_data_imputation(self, hourly_dataframe_filtered, reference_sites, required_sites, site_list_internal):
"""
Function for organising the imputation of the datasets. This runs the
'transform_and_impute_data' function for each of the variables of interest.
Args:
hourly_dataframe_filtered: hourly dataset, for all measurements, as pandas.Dataframe
Index: none
Required Columns:
timestamp (datetime object):
site_id (string):
Optional Columns:
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
reference_sites (list, string or int): sites to use for reference when imputing datasets
required_sites: (dict, keys are species):
items: (list of strings) required sites for `spc`
site_list_internal (list, string or int): combined list of sites to retain
Returns:
output_dataframe: hourly dataset, for all measurements, as pandas.Dataframe
Required Index:
timestamp (datetime object):
site_id (string):
Optional Columns:
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
O3_flag (int): flag indicating imputed data (0=original,1=imputed)
PM10_flag (int):
PM2.5_flag (int):
NO2_flag (int):
NOXasNO2_flag (int):
SO2_flag (int):
"""
transformer = self.transformer_quantile
output_dataframe = pd.DataFrame()
date_index = pd.date_range(start=self.start, end=self.end, freq='1H', name=self._timestamp_string)
# Set the number of reference stations to request
ref_station_numbers = [len(reference_sites[x]) for x in reference_sites.keys()]
print(ref_station_numbers)
station_number = min([5] + [x - 1 for x in ref_station_numbers])
hourly_dataframe_internal = hourly_dataframe_filtered.set_index(self._timestamp_string)
spc_list = self.species_list
if not self._emep_data.empty:
if self.verbose > 0: print('Loading EMEP data')
emep_dataframe_internal = self._emep_data.set_index(self._timestamp_string)
if self.verbose > 1: print('1. Site list internal: ', site_list_internal)
for site in site_list_internal:
if self.verbose > 1: print('2. Site: ', site)
# get list of chemical species that we need to impute for this site (including Date info)
req_spc = []
for spc in spc_list:
if site in required_sites[spc]:
req_spc.append(spc)
# copy these to a new dataframe
working_hourly_dataframe = pd.DataFrame([], index=date_index)
working_hourly_dataframe[req_spc] = \
hourly_dataframe_internal[hourly_dataframe_internal[self._site_string] == site][req_spc]
copy_hourly_dataframe = working_hourly_dataframe.copy()
copy_hourly_dataframe[self._site_string] = site
# get list of neighbouring sites for each of the chemical species of interest
for spc in spc_list:
if self.verbose > 1: print('3. Species: ', spc)
station_distances = self.get_station_distances(site, reference_sites[spc])
if self.verbose > 1: print('4. Station number:', station_number)
if self.verbose > 1: print('5. distances:', station_distances)
if self.verbose > 1: print('6.', len(station_distances))
for ii in range(0, min(station_number, len(station_distances))):
if self.verbose > 1: print('7. ii', ii)
station_code = station_distances.index[ii]
working_hourly_dataframe['{}_{}'.format(spc, station_code)] = \
hourly_dataframe_internal[hourly_dataframe_internal[self._site_string] == station_code][spc]
# get EMEP predictions of chemical species of interest (if needed)
if self.verbose > 1: print('EMEP data: {}'.format(self._emep_data))
if not self._emep_data.empty:
if self.verbose > 0: print('Using EMEP data')
for spc in spc_list:
working_hourly_dataframe['{}_{}'.format(spc, 'EMEP')] = \
emep_dataframe_internal[emep_dataframe_internal[self._site_string] == site][spc]
# run the imputation process
imputed_hourly_dataframe = self.transform_and_impute_data(working_hourly_dataframe,transformer=transformer)
# copy imputed data of interest into copy of original dataframe (without EMEP and neighbouring sites)
for spc in spc_list:
copy_hourly_dataframe['{}_flag'.format(spc)] = 0
if spc in req_spc:
copy_hourly_dataframe['{}_flag'.format(spc)] = copy_hourly_dataframe[spc].isna() * 1
copy_hourly_dataframe[spc] = imputed_hourly_dataframe[spc]
else:
copy_hourly_dataframe[spc] = np.nan
output_dataframe = output_dataframe.append(copy_hourly_dataframe)
output_dataframe = output_dataframe.reset_index().set_index([self._timestamp_string,self._site_string])
return(output_dataframe)
def organise_data(self, hourly_dataframe_filtered, site_list_internal):
"""
Function for organising the required datasets. This mirrors the imputation function.
Args:
hourly_dataframe_filtered: hourly dataset, for all measurements, as pandas.Dataframe
Index: none
Required Columns:
timestamp (datetime object):
site_id (string):
Optional Columns:
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
site_list_internal (list, string or int): combined list of sites to retain
Returns:
hourly_dataframe: hourly dataset, for all measurements, as pandas.Dataframe
Required Index:
timestamp (datetime object):
site_id (string):
Optional Columns:
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
O3_flag (int): flag indicating imputed data (0=original,1=imputed)
PM10_flag (int):
PM2.5_flag (int):
NO2_flag (int):
NOXasNO2_flag (int):
SO2_flag (int):
"""
date_index = pd.date_range(start=self.start, end=self.end, freq='1H', name=self._timestamp_string)
output_dataframe = pd.DataFrame()
hourly_dataframe_internal = hourly_dataframe_filtered.set_index(self._timestamp_string)
spc_list = self.species_list
if self.verbose > 1: print('1. Site list internal: ', site_list_internal)
for site in site_list_internal:
if self.verbose > 1: print('2. Site: ', site)
# create new dataframe, with the dates that we are interested in
working_hourly_dataframe = pd.DataFrame([], index=date_index)
working_hourly_dataframe[self._site_string] = site
# copy these to a new dataframe
working_hourly_dataframe[spc_list] = \
hourly_dataframe_internal[hourly_dataframe_internal[self._site_string] == site][spc_list]
# copy imputed data of interest into copy of original dataframe (without EMEP and neighbouring sites)
for spc in spc_list:
working_hourly_dataframe['{}_flag'.format(spc)] = 0
# append data to the output dataframe
output_dataframe = output_dataframe.append(working_hourly_dataframe)
output_dataframe = output_dataframe.reset_index().set_index([self._timestamp_string,self._site_string])
return(output_dataframe)
def transform_and_impute_data(self, df_in, transformer):
"""
Function for organising the transformation of the dataset, then imputing missing
data, before detransforming the data and returning it.
Args:
df_in: pandas dataframe containing the datasets to impute
Required Index:
date (datetime64 objects): date / time for each reading
Optional Columns: Measurement data at the site for which we are imputing
the data. Only those pollutants which have been measured
at this site will be included.
O3 (float):
PM10 (float):
PM2.5 (float):
NO2 (float):
NOXasNO2 (float):
SO2 (float):
Reference Columns: Reference data at the X nearest sites to the
measurement being processed. All datasets will be
included, even for those pollutants which were not
included in the optional columns above. So, if
5 reference stations are used, this will give 30 (5*6)
columns of reference data. If EMEP data is being used
then these are added for EMEP data too, but only at
the station of interest (so only another 6 columns are
added).
O3_[site_id] (float):
PM10_[site_id] (float):
PM2.5_[site_id] (float):
NO2_[site_id] (float):
NOXasNO2_[site_id] (float):
SO2_[site_id] (float):
transformer: the transform function to use, passed so that we can chose based
on the variable being operated on
Uses:
self.imputer
Returns:
df_out: pandas dataframe, containing the same datasets as above, but including
the imputed data too. All imputed data is included (including that for
the reference sites) - it is the task of the calling function to only
retain the imputed data for the station of interest, and to discard
the rest of the imputed data.
"""
# copy the input array, and note the columns
df_work = df_in.copy(deep=True)
cols = df_in.columns
# find missing datasets to remove
# also we note the columns that will be saved, and their order, for transferring data back!
col_remove = []
col_save = []
for col in cols:
if all(df_work[col].isna()):
col_remove.append(col)
else:
col_save.append(col)
df_work = df_work.drop(columns=col_remove)
if self.verbose > 2: print('df_work input to power transformer: \n {}'.format(df_work))
# power transformer fitting and transforming
transformer.fit(df_work.dropna())
if self.verbose > 2: print('Power transformer: Completed data fitting. Beginning power transformation')
np_out = transformer.transform(df_work)
if self.verbose > 2: print('Power transformer: Completed transformation. Beginning imputation')
# impute the missing values in this new dataframe
self.imputer.fit(np_out)
if self.verbose > 2: print('Imputer: Completed imputation fitting. Beginning imputer tranformation')
imp_out = self.imputer.transform(np_out)
if self.verbose > 2: print('Imputer Completed transformation. Beginning inverse transformation')
# apply the inverse transformation for our datasets (leaving out the indicator flags)
np_inv = transformer.inverse_transform(imp_out[:, :np_out.shape[1]])
if self.verbose > 2: print('Imputer Completed inverse transformation. Beginning copying and tranforming values')
# copy the transformed values to a new dataframe
df_out = df_in.copy(deep=True)
for pos, col in enumerate(col_save):
pos_out = list(cols).index(col)
df_out.iloc[:, pos_out] = np_inv[:, pos]
if self.verbose > 1: print('Imputation: copied transformed values into new dataframe')
return df_out
| python |
from .util import *
from .db import Database
from .optimizer import *
from .ops import Print, Yield
from .parseops import *
from .udfs import *
from .parse_sql import parse
from .tuples import *
from .tables import *
from .schema import Schema
from .exprs import Attr
from .compile import *
from .context import *
| python |
from __future__ import print_function
import getopt
def usage():
print("""Usage: check_asdis -i <pcap_file> [-o <wrong_packets.pcap>]
-v increase verbosity
-d hexdiff packets that differ
-z compress output pcap
-a open pcap file in append mode""", file=sys.stderr)
def main(argv):
PCAP_IN = None
PCAP_OUT = None
COMPRESS = False
APPEND = False
DIFF = False
VERBOSE = 0
try:
opts = getopt.getopt(argv, "hi:o:azdv")
for opt, parm in opts[0]:
if opt == "-h":
usage()
raise SystemExit
elif opt == "-i":
PCAP_IN = parm
elif opt == "-o":
PCAP_OUT = parm
elif opt == "-v":
VERBOSE += 1
elif opt == "-d":
DIFF = True
elif opt == "-a":
APPEND = True
elif opt == "-z":
COMPRESS = True
if PCAP_IN is None:
raise getopt.GetoptError("Missing pcap file (-i)")
except getopt.GetoptError as e:
print("ERROR: %s" % e, file=sys.stderr)
raise SystemExit
from scapy.config import conf
from scapy.utils import RawPcapReader, RawPcapWriter, hexdiff
from scapy.layers import all # noqa: F401
pcap = RawPcapReader(PCAP_IN)
pcap_out = None
if PCAP_OUT:
pcap_out = RawPcapWriter(PCAP_OUT, append=APPEND, gz=COMPRESS, linktype=pcap.linktype) # noqa: E501
pcap_out._write_header(None)
LLcls = conf.l2types.get(pcap.linktype)
if LLcls is None:
print(" Unknown link type [%i]. Can't test anything!" % pcap.linktype, file=sys.stderr) # noqa: E501
raise SystemExit
i = -1
differ = 0
failed = 0
for p1, meta in pcap:
i += 1
try:
p2d = LLcls(p1)
p2 = str(p2d)
except KeyboardInterrupt:
raise
except Exception as e:
print("Dissection error on packet %i: %s" % (i, e))
failed += 1
else:
if p1 == p2:
if VERBOSE >= 2:
print("Packet %i ok" % i)
continue
else:
print("Packet %i differs" % i)
differ += 1
if VERBOSE >= 1:
print(repr(p2d))
if DIFF:
hexdiff(p1, p2)
if pcap_out is not None:
pcap_out.write(p1)
i += 1
correct = i - differ - failed
print("%i total packets. %i ok, %i differed, %i failed. %.2f%% correct." % (i, correct, differ, # noqa: E501
failed, i and 100.0 * (correct) / i)) # noqa: E501
if __name__ == "__main__":
import sys
try:
main(sys.argv[1:])
except KeyboardInterrupt:
print("Interrupted by user.", file=sys.stderr)
| python |
# coding=utf-8
# Copyright 2022 The HuggingFace Inc. team.
#
# 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.
"""
Processor class for ViLT.
"""
from typing import List, Optional, Union
from transformers import BertTokenizerFast
from ...file_utils import TensorType
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from .feature_extraction_vilt import ViltFeatureExtractor
class ViltProcessor:
r"""
Constructs a ViLT processor which wraps a BERT tokenizer and ViLT feature extractor into a single processor.
[`ViltProcessor`] offers all the functionalities of [`ViltFeatureExtractor`] and [`BertTokenizerFast`]. See the
docstring of [`~ViltProcessor.__call__`] and [`~ViltProcessor.decode`] for more information.
Args:
feature_extractor (`ViltFeatureExtractor`):
An instance of [`ViltFeatureExtractor`]. The feature extractor is a required input.
tokenizer (`BertTokenizerFast`):
An instance of ['BertTokenizerFast`]. The tokenizer is a required input.
"""
def __init__(self, feature_extractor, tokenizer):
if not isinstance(feature_extractor, ViltFeatureExtractor):
raise ValueError(
f"`feature_extractor` has to be of type {ViltFeatureExtractor.__class__}, but is {type(feature_extractor)}"
)
if not isinstance(tokenizer, BertTokenizerFast):
raise ValueError(f"`tokenizer` has to be of type {BertTokenizerFast.__class__}, but is {type(tokenizer)}")
self.feature_extractor = feature_extractor
self.tokenizer = tokenizer
self.current_processor = self.feature_extractor
def save_pretrained(self, save_directory):
"""
Save a ViLT feature_extractor object and BERT tokenizer object to the directory `save_directory`, so that it
can be re-loaded using the [`~ViltProcessor.from_pretrained`] class method.
<Tip>
This class method is simply calling [`~feature_extraction_utils.FeatureExtractionMixin.save_pretrained`] and
[`~tokenization_utils_base.PreTrainedTokenizer.save_pretrained`]. Please refer to the docstrings of the methods
above for more information.
</Tip>
Args:
save_directory (`str` or `os.PathLike`):
Directory where the feature extractor JSON file and the tokenizer files will be saved (directory will
be created if it does not exist).
"""
self.feature_extractor.save_pretrained(save_directory)
self.tokenizer.save_pretrained(save_directory)
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path, **kwargs):
r"""
Instantiate a [`ViltProcessor`] from a pretrained ViLT processor.
<Tip>
This class method is simply calling ViltFeatureExtractor's
[`~feature_extraction_utils.FeatureExtractionMixin.from_pretrained`] and BertTokenizerFast's
[`~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`]. Please refer to the docstrings of the methods
above for more information.
</Tip>
Args:
pretrained_model_name_or_path (`str` or `os.PathLike`):
This can be either:
- a string, the *model id* of a pretrained feature_extractor hosted inside a model repo on
huggingface.co. Valid model ids can be located at the root-level, like `bert-base-uncased`, or
namespaced under a user or organization name, like `dbmdz/bert-base-german-cased`.
- a path to a *directory* containing a feature extractor file saved using the
[`~SequenceFeatureExtractor.save_pretrained`] method, e.g., `./my_model_directory/`.
- a path or url to a saved feature extractor JSON *file*, e.g.,
`./my_model_directory/preprocessor_config.json`.
**kwargs
Additional keyword arguments passed along to both [`SequenceFeatureExtractor`] and
[`PreTrainedTokenizer`]
"""
feature_extractor = ViltFeatureExtractor.from_pretrained(pretrained_model_name_or_path, **kwargs)
tokenizer = BertTokenizerFast.from_pretrained(pretrained_model_name_or_path, **kwargs)
return cls(feature_extractor=feature_extractor, tokenizer=tokenizer)
def __call__(
self,
images,
text: Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None,
add_special_tokens: bool = True,
padding: Union[bool, str, PaddingStrategy] = False,
truncation: Union[bool, str, TruncationStrategy] = False,
max_length: Optional[int] = None,
stride: int = 0,
pad_to_multiple_of: Optional[int] = None,
return_token_type_ids: Optional[bool] = None,
return_attention_mask: Optional[bool] = None,
return_overflowing_tokens: bool = False,
return_special_tokens_mask: bool = False,
return_offsets_mapping: bool = False,
return_length: bool = False,
verbose: bool = True,
return_tensors: Optional[Union[str, TensorType]] = None,
**kwargs
) -> BatchEncoding:
"""
This method uses [`ViltFeatureExtractor.__call__`] method to prepare image(s) for the model, and
[`BertTokenizerFast.__call__`] to prepare text for the model.
Please refer to the docstring of the above two methods for more information.
"""
encoding = self.tokenizer(
text=text,
add_special_tokens=add_special_tokens,
padding=padding,
truncation=truncation,
max_length=max_length,
stride=stride,
pad_to_multiple_of=pad_to_multiple_of,
return_token_type_ids=return_token_type_ids,
return_attention_mask=return_attention_mask,
return_overflowing_tokens=return_overflowing_tokens,
return_special_tokens_mask=return_special_tokens_mask,
return_offsets_mapping=return_offsets_mapping,
return_length=return_length,
verbose=verbose,
return_tensors=return_tensors,
**kwargs,
)
# add pixel_values + pixel_mask
encoding_feature_extractor = self.feature_extractor(images, return_tensors=return_tensors)
encoding.update(encoding_feature_extractor)
return encoding
def batch_decode(self, *args, **kwargs):
"""
This method forwards all its arguments to BertTokenizerFast's [`~PreTrainedTokenizer.batch_decode`]. Please
refer to the docstring of this method for more information.
"""
return self.tokenizer.batch_decode(*args, **kwargs)
def decode(self, *args, **kwargs):
"""
This method forwards all its arguments to BertTokenizerFast's [`~PreTrainedTokenizer.decode`]. Please refer to
the docstring of this method for more information.
"""
return self.tokenizer.decode(*args, **kwargs)
| python |
from mr_scraper.api import dispatch, ScraperMessage
def levels_fyi():
"""Scraper using Puppeter"""
message = ScraperMessage(
scraper="example.scrapers.levels_fyi",
type='companies',
payload={'url': '/company/'}
)
return dispatch(message)
| python |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
version = '0.12.0'
setup(
name='SerpScrap',
version=version,
description='''
SEO python scraper to extract data from major searchengine result pages.
Extract data like url, title, snippet, richsnippet and the type from searchresults for given keywords. Detect Ads or make automated screenshots.
You can also fetch text content of urls provided in searchresults or by your own.
It's usefull for SEO and business related research tasks.
''',
long_description=open('README.rst').read(),
author='Ronald Schmidt',
author_email='[email protected]',
doc_url='http://serpscrap.readthedocs.io/en/latest/',
url='https://github.com/ecoron/SerpScrap',
license='MIT',
packages=find_packages(),
install_requires=[
'PySocks==1.6.8',
'chardet==3.0.4',
'beautifulsoup4==4.6.3',
'html2text==2018.1.9',
'lxml==4.2.3',
'sqlalchemy==1.2.10',
'selenium==3.14.1',
'cssselect==1.0.3',
],
scripts=['install_chrome.sh'],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'Topic :: Internet',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
],
keywords='seo scraper ad-detection scraping keywords',
)
| python |
import json
import subprocess
from oslo_log import log as logging
from magnum.common import exception
LOG = logging.getLogger(__name__)
class KubeCtl(object):
def __init__(self, bin='kubectl', global_flags=''):
super(KubeCtl, self).__init__()
self.kubectl = '{} {}'.format(bin, global_flags)
def execute(self, command, definition=None, namespace=None,
print_error=True):
if definition:
cmd = "cat <<'EOF' | {} {} -f -\n{}\nEOF".format(
self.kubectl, command, definition
)
else:
if namespace:
cmd = "{} -n {} {}".format(self.kubectl, namespace, command)
else:
cmd = "{} {}".format(self.kubectl, command)
try:
r = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
return r
# except subprocess.CalledProcessError as ex:
# # if print_error:
# if "delete" in command:
# LOG.warning("K8s: Delete failed.")
# else:
# exc_msg = "Failed to execute kubectl command, cmd={}, err={}".format(cmd, ex.stderr.decode())
# LOG.error(exc_msg)
# raise exception.MagnumException(message=exc_msg)
except Exception as ex:
# if print_error:
if "delete" in command:
LOG.warning("K8s: Delete failed.")
else:
exc_msg = "Failed to execute kubectl command, cmd={},\n STDOUT/STDERR={}".format(cmd, ex.stdout.decode())
LOG.error(exc_msg)
raise exception.MagnumException(message="Failed to execute kubectl command")
def apply(self, *args, **kwargs):
return self.execute('apply', *args, **kwargs)
def delete(self, *args, **kwargs):
return self.execute('delete', *args, **kwargs)
def get(self, resource, namespace=None, **kwargs):
result = self.execute(
'get %s -o json' % resource, namespace=namespace, **kwargs
).decode()
ret = json.loads(result)
if 'items' in ret:
return ret['items']
return ret
def describe(self, *args, **kwargs):
return self.execute('describe', *args, **kwargs)
def batch_delete(self, resource_mapping=[]):
"""Deletes Kubernetes resources.
Example for the resource_mapping param:
[{"service": ["srv1", "srv2"]}, {"deployment": ["deploy1"]}]
Be careful to the deletion order.
"""
for res in resource_mapping:
for res_type, items in res.items():
resources = " ".join(items)
self.execute("delete %s %s" % (res_type, resources))
| python |
import json
import cfnresponse
def lambda_handler(event, context):
print(json.dumps(event))
response_data = {}
response_data['Data'] = None
if event['RequestType'] != 'Create':
cfnresponse.send(event, context, cfnresponse.SUCCESS,
response_data, "CustomResourcePhysicalID")
return
password = event['ResourceProperties']['Password']
confirm_password = event['ResourceProperties']['ConfirmPassword']
if password == confirm_password:
cfnresponse.send(event, context, cfnresponse.SUCCESS,
response_data, "CustomResourcePhysicalID")
else:
print('Passwords do not match!')
cfnresponse.send(event, context, cfnresponse.FAILED,
response_data, "CustomResourcePhysicalID")
| python |
from typing import NamedTuple
from thundersnow.precondition import check_argument
from thundersnow.predicate import is_not_blank
class Version(NamedTuple):
"""Sematnic Version object"""
major: str
minort: str
patch: str
def __str__(self):
return '.'.join(self)
def from_string(s):
""" '1.2.3' -> Version('1','2','3')"""
s = str(s)
check_argument((s is not None) and is_not_blank(s), 'cannot create version from blank string')
parts = s.split('.')
if len(parts) == 1:
major, minor, patch = (parts[0], 0, 0)
elif len(parts) == 2:
major, minor, patch = (parts[0], parts[1], 0)
elif len(parts) == 3:
major, minor, patch = parts
else:
major, minor, patch = parts[:3]
major, minor, patch = [str(i) for i in (major, minor, patch)]
return Version(major, minor, patch)
Version.from_string = from_string | python |
import sys
from loguru import logger
logger.remove()
logger.add(sys.stderr, format="", colorize=True, backtrace=False, diagnose=True)
def div(x, y):
x / y
def cause(x, y):
try:
div(x, y)
except Exception:
raise ValueError("Division error")
def context(x, y):
try:
cause(x, y)
except Exception as e:
raise ValueError("Cause error") from e
try:
context(1, 0)
except ValueError:
logger.exception("")
| python |
import numpy as np
print("Did you know 2 + 2 = {}".format(2+2))
print("Of course I knew that, I have 4 fingers")
print("Well, I knew you had 4 fingers. I didn't know that you knew how to count!") | python |