text
stringlengths
6
947k
repo_name
stringlengths
5
100
path
stringlengths
4
231
language
stringclasses
1 value
license
stringclasses
15 values
size
int64
6
947k
score
float64
0
0.34
from allauth.socialaccount.tests import OAuth2TestsMixin from allauth.tests import MockedResponse, TestCase from .provider import MicrosoftGraphProvider class MicrosoftGraphTests(OAuth2TestsMixin, TestCase): provider_id = MicrosoftGraphProvider.id def get_mocked_response(self): response_data = """ { "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#users/$entity", "id": "16f5a7b6-5a15-4568-aa5a-31bb117e9967", "businessPhones": [], "displayName": "Anne Weiler", "givenName": "Anne", "jobTitle": "Manufacturing Lead", "mail": "annew@CIE493742.onmicrosoft.com", "mobilePhone": "+1 3528700812", "officeLocation": null, "preferredLanguage": "en-US", "surname": "Weiler", "userPrincipalName": "annew@CIE493742.onmicrosoft.com" } """ # noqa return MockedResponse(200, response_data)
AltSchool/django-allauth
allauth/socialaccount/providers/microsoft/tests.py
Python
mit
988
0.001012
""" Python environments and packages ================================ This module provides tools for using Python `virtual environments`_ and installing Python packages using the `pip`_ installer. .. _virtual environments: http://www.virtualenv.org/ .. _pip: http://www.pip-installer.org/ """ from __future__ import with_statement from contextlib import contextmanager from distutils.version import StrictVersion as V from pipes import quote import os import posixpath import re from fabric.api import cd, hide, prefix, run, settings, sudo from fabric.utils import puts from fabtools.files import is_file from fabtools.utils import abspath, download, run_as_root GET_PIP_URL = 'https://raw.githubusercontent.com/pypa/pip/master/contrib/get-pip.py' def is_pip_installed(version=None, pip_cmd='pip'): """ Check if `pip`_ is installed. .. _pip: http://www.pip-installer.org/ """ with settings(hide('running', 'warnings', 'stderr', 'stdout'), warn_only=True): res = run('%(pip_cmd)s --version 2>/dev/null' % locals()) if res.failed: return False if version is None: return res.succeeded else: m = re.search(r'pip (?P<version>.*) from', res) if m is None: return False installed = m.group('version') if V(installed) < V(version): puts("pip %s found (version >= %s required)" % (installed, version)) return False else: return True def install_pip(python_cmd='python', use_sudo=True): """ Install the latest version of `pip`_, using the given Python interpreter. :: import fabtools if not fabtools.python.is_pip_installed(): fabtools.python.install_pip() .. note:: pip is automatically installed inside a virtualenv, so there is no need to install it yourself in this case. .. _pip: http://www.pip-installer.org/ """ with cd('/tmp'): download(GET_PIP_URL) command = '%(python_cmd)s get-pip.py' % locals() if use_sudo: run_as_root(command, pty=False) else: run(command, pty=False) run('rm -f get-pip.py') def is_installed(package, pip_cmd='pip'): """ Check if a Python package is installed (using pip). Package names are case insensitive. Example:: from fabtools.python import virtualenv import fabtools with virtualenv('/path/to/venv'): fabtools.python.install('Flask') assert fabtools.python.is_installed('flask') .. _pip: http://www.pip-installer.org/ """ with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True): res = run('%(pip_cmd)s freeze' % locals()) packages = [line.split('==')[0].lower() for line in res.splitlines()] return (package.lower() in packages) def install(packages, upgrade=False, download_cache=None, allow_external=None, allow_unverified=None, quiet=False, pip_cmd='pip', use_sudo=False, user=None, exists_action=None): """ Install Python package(s) using `pip`_. Package names are case insensitive. Starting with version 1.5, pip no longer scrapes insecure external urls by default and no longer installs externally hosted files by default. Use ``allow_external=['foo', 'bar']`` or ``allow_unverified=['bar', 'baz']`` to change these behaviours for specific packages. Examples:: import fabtools # Install a single package fabtools.python.install('package', use_sudo=True) # Install a list of packages fabtools.python.install(['pkg1', 'pkg2'], use_sudo=True) .. _pip: http://www.pip-installer.org/ """ if isinstance(packages, basestring): packages = [packages] if allow_external in (None, False): allow_external = [] elif allow_external == True: allow_external = packages if allow_unverified in (None, False): allow_unverified = [] elif allow_unverified == True: allow_unverified = packages options = [] if upgrade: options.append('--upgrade') if download_cache: options.append('--download-cache="%s"' % download_cache) if quiet: options.append('--quiet') for package in allow_external: options.append('--allow-external="%s"' % package) for package in allow_unverified: options.append('--allow-unverified="%s"' % package) if exists_action: options.append('--exists-action=%s' % exists_action) options = ' '.join(options) packages = ' '.join(packages) command = '%(pip_cmd)s install %(options)s %(packages)s' % locals() if use_sudo: sudo(command, user=user, pty=False) else: run(command, pty=False) def install_requirements(filename, upgrade=False, download_cache=None, allow_external=None, allow_unverified=None, quiet=False, pip_cmd='pip', use_sudo=False, user=None, exists_action=None): """ Install Python packages from a pip `requirements file`_. :: import fabtools fabtools.python.install_requirements('project/requirements.txt') .. _requirements file: http://www.pip-installer.org/en/latest/requirements.html """ if allow_external is None: allow_external = [] if allow_unverified is None: allow_unverified = [] options = [] if upgrade: options.append('--upgrade') if download_cache: options.append('--download-cache="%s"' % download_cache) for package in allow_external: options.append('--allow-external="%s"' % package) for package in allow_unverified: options.append('--allow-unverified="%s"' % package) if quiet: options.append('--quiet') if exists_action: options.append('--exists-action=%s' % exists_action) options = ' '.join(options) command = '%(pip_cmd)s install %(options)s -r %(filename)s' % locals() if use_sudo: sudo(command, user=user, pty=False) else: run(command, pty=False) def create_virtualenv(directory, system_site_packages=False, venv_python=None, use_sudo=False, user=None, clear=False, prompt=None, virtualenv_cmd='virtualenv'): """ Create a Python `virtual environment`_. :: import fabtools fabtools.python.create_virtualenv('/path/to/venv') .. _virtual environment: http://www.virtualenv.org/ """ options = ['--quiet'] if system_site_packages: options.append('--system-site-packages') if venv_python: options.append('--python=%s' % quote(venv_python)) if clear: options.append('--clear') if prompt: options.append('--prompt=%s' % quote(prompt)) options = ' '.join(options) directory = quote(directory) command = '%(virtualenv_cmd)s %(options)s %(directory)s' % locals() if use_sudo: sudo(command, user=user) else: run(command) def virtualenv_exists(directory): """ Check if a Python `virtual environment`_ exists. .. _virtual environment: http://www.virtualenv.org/ """ return is_file(posixpath.join(directory, 'bin', 'python')) @contextmanager def virtualenv(directory, local=False): """ Context manager to activate an existing Python `virtual environment`_. :: from fabric.api import run from fabtools.python import virtualenv with virtualenv('/path/to/virtualenv'): run('python -V') .. _virtual environment: http://www.virtualenv.org/ """ path_mod = os.path if local else posixpath # Build absolute path to the virtualenv activation script venv_path = abspath(directory) activate_path = path_mod.join(venv_path, 'bin', 'activate') # Source the activation script with prefix('. %s' % quote(activate_path)): yield
juanantoniofm/accesible-moodle
fabtools/python.py
Python
gpl-2.0
8,076
0.001114
# testing: to be called by nosetests import os from stetl.etl import ETL from tests.stetl_test_case import StetlTestCase from stetl.main import parse_args class ConfigTest(StetlTestCase): """Basic configuration tests""" def setUp(self): super(ConfigTest, self).setUp() # Initialize Stetl self.curr_dir = os.path.dirname(os.path.realpath(__file__)) self.cfg_dict = {'config_file': os.path.join(self.curr_dir, 'configs/copy_in_out_file.cfg')} def clear_stetl_env(self): # Restore old enviroment try: del os.environ['stetl_out_file'] del os.environ['stetl_in_file'] except: pass def tearDown(self): super(ConfigTest, self).tearDown() self.clear_stetl_env() def test_config_args_file_single(self): """ Test single -a argsfile option :return: """ args_default = os.path.join(self.curr_dir, 'configs/copy_in_out_file_default.args') args_parsed = parse_args(['-a', args_default]) # Test args substitution from args_dict config_args = args_parsed.config_args self.assertEqual(config_args['in_file'], 'default_infile.txt') self.assertEqual(config_args['out_file'], 'default_outfile.txt') def test_config_args_explicit_single(self): """ Test single -a "arg1=x arg2=y" option :return: """ args_default = os.path.join(self.curr_dir, 'configs/copy_in_out_file_default.args') args_parsed = parse_args(['-a', 'in_file=default_infile.txt out_file=default_outfile.txt']) # Test args substitution from args_dict config_args = args_parsed.config_args self.assertEqual(config_args['in_file'], 'default_infile.txt') self.assertEqual(config_args['out_file'], 'default_outfile.txt') def test_config_args_file_multi(self): """ Test multiple: -a argsfile1 -a argsfile2 option with override :return: """ args_default = os.path.join(self.curr_dir, 'configs/copy_in_out_file_default.args') args_my = os.path.join(self.curr_dir, 'configs/copy_in_out_file_my.args') args_parsed = parse_args(['-a', args_default, '-a', args_my]) # Test args substitution from args_dict config_args = args_parsed.config_args self.assertEqual(config_args['in_file'], 'my_infile.txt') self.assertEqual(config_args['out_file'], 'default_outfile.txt') def test_config_args_file_explicit_multi(self): """ Test multiple: -a argsfile1 -a arg=myarg option with override :return: """ args_default = os.path.join(self.curr_dir, 'configs/copy_in_out_file_default.args') args_parsed = parse_args(['-a', args_default, '-a', 'in_file=my_infile.txt']) # Test args substitution from args_dict config_args = args_parsed.config_args self.assertEqual(config_args['in_file'], 'my_infile.txt') self.assertEqual(config_args['out_file'], 'default_outfile.txt') def test_args_dict(self): args_dict = {'in_file': 'infile.txt', 'out_file': 'outfile.txt'} etl = ETL(self.cfg_dict, args_dict) # Test args substitution from args_dict self.assertEqual(etl.configdict.get('input_file', 'file_path'), 'infile.txt') self.assertEqual(etl.configdict.get('output_file', 'file_path'), 'outfile.txt') def test_args_dict_env_override(self): args_dict = {'in_file': 'infile.txt', 'out_file': 'outfile.txt'} # Override in OS env os.environ['stetl_in_file'] = 'env_infile.txt' etl = ETL(self.cfg_dict, args_dict) # Test args substitution from args_dict self.assertEqual(etl.configdict.get('input_file', 'file_path'), os.environ['stetl_in_file']) self.assertEqual(etl.configdict.get('output_file', 'file_path'), 'outfile.txt') def test_args_dict_env_all(self): """ Substitute ALL args from OS env. :return: """ # Set all args in in OS env os.environ['stetl_in_file'] = 'env_infile.txt' os.environ['stetl_out_file'] = 'env_outfile.txt' args_dict = None etl = ETL(self.cfg_dict, args_dict) # Test args substitution from args_dict self.assertEqual(etl.configdict.get('input_file', 'file_path'), os.environ['stetl_in_file']) self.assertEqual(etl.configdict.get('output_file', 'file_path'), os.environ['stetl_out_file'])
justb4/stetl
tests/test_args.py
Python
gpl-3.0
4,523
0.003537
#!/usr/bin/env python import os.path programName = os.path.splitext(os.path.basename(__file__))[0] from sys import argv,stdin,stderr,exit from pazookle.shred import zook,Shreduler from pazookle.ugen import UGen,Mixer from pazookle.generate import SinOsc from pazookle.output import WavOut from pazookle.parse import float_or_fraction def usage(s=None): message = """ usage: %s [options] --freq1=<value> set the first frequency --freq2=<value> set the second frequency --dry=<value> set dry level (mix for second oscillator) --wet=<value> set wet level (mix for second oscillator) --channels=<1|2> number of output channels --duration=<seconds> length of the test""" \ % programName if (s == None): exit (message) else: exit ("%s\n%s" % (s,message)) def main(): global debug global freq1,freq2,dry,wet,numChannels # parse the command line freq1 = 440.0 freq2 = 660.0 dry = 0.5 wet = 0.2 numChannels = 1 duration = 3.0 debug = [] for arg in argv[1:]: if ("=" in arg): argVal = arg.split("=",1)[1] if (arg.startswith("F1=")) or (arg.startswith("--freq1=")) or (arg.startswith("--frequency1=")): freq1 = float_or_fraction(argVal) elif (arg.startswith("F2=")) or (arg.startswith("--freq2=")) or (arg.startswith("--frequency2=")): freq2 = float_or_fraction(argVal) elif (arg.startswith("D=")) or (arg.startswith("--dry=")): dry = float_or_fraction(argVal) elif (arg.startswith("W=")) or (arg.startswith("--wet=")): wet = float_or_fraction(argVal) elif (arg.startswith("--channels=")): numChannels = int(argVal) elif (arg.startswith("T=")) or (arg.startswith("--dur=")) or (arg.startswith("--duration=")): duration = float_or_fraction(argVal) elif (arg == "--help"): usage() elif (arg.startswith("--debug=")): debug += argVal.split(",") elif (arg.startswith("--")): usage("unrecognized option: %s" % arg) else: usage("unrecognized option: %s" % arg) # run the test UGen.set_debug(debug) Shreduler.set_debug(debug) zook.spork(mixer_test(duration*zook.sec)) zook.run() def mixer_test(duration): filename = programName + ".wav" print >>stderr, "writing audio output to %s" % filename output = WavOut(filename=filename,channels=numChannels) osc1 = SinOsc(gain=1.0,freq=freq1) osc2 = SinOsc(gain=1.0,freq=freq2) mixer = Mixer(dry=dry,wet=wet,channels=numChannels) osc1 >> mixer >> output osc2 >> mixer yield duration output.close() if __name__ == "__main__": main()
zacko-belsch/pazookle
tests/try_Mixer.py
Python
gpl-3.0
2,580
0.037209
# -*- coding:utf-8; mode:python -*- """ Implements a queue efficiently using only two stacks. """ from helpers import SingleNode from stack import Stack class QueueOf2Stacks: def __init__(self): self.stack_1 = Stack() self.stack_2 = Stack() def enqueue(self, value): self.stack_1.push(value) def dequeue(self): self.transfer_if_necessary() if self.stack_2: return self.stack_2.pop() def peek(self): self.transfer_if_necessary() if self.stack_2: return self.stack_2.peek() def transfer_if_necessary(self): if not self.stack_2: while self.stack_1: self.stack_2.push(self.stack_1.pop()) def __len__(self): return len(self.stack_1) + len(self.stack_2) def main(): queue = QueueOf2Stacks() print() for i in range(10): queue.enqueue(i) print(i) print("---") for i in range(len(queue)): print(queue.dequeue()) if __name__ == "__main__": main() main()
wkmanire/StructuresAndAlgorithms
pythonpractice/queueoftwostacks.py
Python
gpl-3.0
1,054
0
#!/usr/bin/python # # Copyright (c) 2011 The Bitcoin developers // Copyright (c) 2014 Dyffy, Inc. # Distributed under the MIT/X11 software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. # import time import json import pprint import hashlib import struct import re import base64 import httplib import sys from multiprocessing import Process ERR_SLEEP = 15 MAX_NONCE = 1000000L settings = {} pp = pprint.PrettyPrinter(indent=4) class SidecoinRPC: OBJID = 1 def __init__(self, host, port, username, password): authpair = "%s:%s" % (username, password) self.authhdr = "Basic %s" % (base64.b64encode(authpair)) self.conn = httplib.HTTPConnection(host, port, False, 30) def rpc(self, method, params=None): self.OBJID += 1 obj = { 'version' : '1.1', 'method' : method, 'id' : self.OBJID } if params is None: obj['params'] = [] else: obj['params'] = params self.conn.request('POST', '/', json.dumps(obj), { 'Authorization' : self.authhdr, 'Content-type' : 'application/json' }) resp = self.conn.getresponse() if resp is None: print "JSON-RPC: no response" return None body = resp.read() resp_obj = json.loads(body) if resp_obj is None: print "JSON-RPC: cannot JSON-decode body" return None if 'error' in resp_obj and resp_obj['error'] != None: return resp_obj['error'] if 'result' not in resp_obj: print "JSON-RPC: no result in object" return None return resp_obj['result'] def getblockcount(self): return self.rpc('getblockcount') def getwork(self, data=None): return self.rpc('getwork', data) def uint32(x): return x & 0xffffffffL def bytereverse(x): return uint32(( ((x) << 24) | (((x) << 8) & 0x00ff0000) | (((x) >> 8) & 0x0000ff00) | ((x) >> 24) )) def bufreverse(in_buf): out_words = [] for i in range(0, len(in_buf), 4): word = struct.unpack('@I', in_buf[i:i+4])[0] out_words.append(struct.pack('@I', bytereverse(word))) return ''.join(out_words) def wordreverse(in_buf): out_words = [] for i in range(0, len(in_buf), 4): out_words.append(in_buf[i:i+4]) out_words.reverse() return ''.join(out_words) class Miner: def __init__(self, id): self.id = id self.max_nonce = MAX_NONCE def work(self, datastr, targetstr): # decode work data hex string to binary static_data = datastr.decode('hex') static_data = bufreverse(static_data) # the first 76b of 80b do not change blk_hdr = static_data[:76] # decode 256-bit target value targetbin = targetstr.decode('hex') targetbin = targetbin[::-1] # byte-swap and dword-swap targetbin_str = targetbin.encode('hex') target = long(targetbin_str, 16) # pre-hash first 76b of block header static_hash = hashlib.sha256() static_hash.update(blk_hdr) for nonce in xrange(self.max_nonce): # encode 32-bit nonce value nonce_bin = struct.pack("<I", nonce) # hash final 4b, the nonce value hash1_o = static_hash.copy() hash1_o.update(nonce_bin) hash1 = hash1_o.digest() # sha256 hash of sha256 hash hash_o = hashlib.sha256() hash_o.update(hash1) hash = hash_o.digest() # quick test for winning solution: high 32 bits zero? if hash[-4:] != '\0\0\0\0': continue # convert binary hash to 256-bit Python long hash = bufreverse(hash) hash = wordreverse(hash) hash_str = hash.encode('hex') l = long(hash_str, 16) # proof-of-work test: hash < target if l < target: print time.asctime(), "PROOF-OF-WORK found: %064x" % (l,) return (nonce + 1, nonce_bin) else: print time.asctime(), "PROOF-OF-WORK false positive %064x" % (l,) # return (nonce + 1, nonce_bin) return (nonce + 1, None) def submit_work(self, rpc, original_data, nonce_bin): nonce_bin = bufreverse(nonce_bin) nonce = nonce_bin.encode('hex') solution = original_data[:152] + nonce + original_data[160:256] param_arr = [ solution ] result = rpc.getwork(param_arr) print time.asctime(), "--> Upstream RPC result:", result def iterate(self, rpc): work = rpc.getwork() if work is None: time.sleep(ERR_SLEEP) return if 'data' not in work or 'target' not in work: time.sleep(ERR_SLEEP) return time_start = time.time() (hashes_done, nonce_bin) = self.work(work['data'], work['target']) time_end = time.time() time_diff = time_end - time_start self.max_nonce = long( (hashes_done * settings['scantime']) / time_diff) if self.max_nonce > 0xfffffffaL: self.max_nonce = 0xfffffffaL if settings['hashmeter']: print "HashMeter(%d): %d hashes, %.2f Khash/sec" % ( self.id, hashes_done, (hashes_done / 1000.0) / time_diff) if nonce_bin is not None: self.submit_work(rpc, work['data'], nonce_bin) def loop(self): rpc = SidecoinRPC(settings['host'], settings['port'], settings['rpcuser'], settings['rpcpass']) if rpc is None: return while True: self.iterate(rpc) def miner_thread(id): miner = Miner(id) miner.loop() if __name__ == '__main__': if len(sys.argv) != 2: print "Usage: pyminer.py CONFIG-FILE" sys.exit(1) f = open(sys.argv[1]) for line in f: # skip comment lines m = re.search('^\s*#', line) if m: continue # parse key=value lines m = re.search('^(\w+)\s*=\s*(\S.*)$', line) if m is None: continue settings[m.group(1)] = m.group(2) f.close() if 'host' not in settings: settings['host'] = '127.0.0.1' if 'port' not in settings: settings['port'] = 8332 if 'threads' not in settings: settings['threads'] = 1 if 'hashmeter' not in settings: settings['hashmeter'] = 0 if 'scantime' not in settings: settings['scantime'] = 30L if 'rpcuser' not in settings or 'rpcpass' not in settings: print "Missing username and/or password in cfg file" sys.exit(1) settings['port'] = int(settings['port']) settings['threads'] = int(settings['threads']) settings['hashmeter'] = int(settings['hashmeter']) settings['scantime'] = long(settings['scantime']) thr_list = [] for thr_id in range(settings['threads']): p = Process(target=miner_thread, args=(thr_id,)) p.start() thr_list.append(p) time.sleep(1) # stagger threads print settings['threads'], "mining threads started" print time.asctime(), "Miner Starts - %s:%s" % (settings['host'], settings['port']) try: for thr_proc in thr_list: thr_proc.join() except KeyboardInterrupt: pass print time.asctime(), "Miner Stops - %s:%s" % (settings['host'], settings['port'])
joeykrug/sidecoin
contrib/pyminer/pyminer.py
Python
mit
6,470
0.036321
# example for using Python with cython bindings as a [HAL]HALFILE # in the ini file, add as last HALFILE: #[HAL] #HALFILE = haltest.py from machinekit.halfile import rt, hal rt.loadrt("supply") hal.addf("supply.0.update","servo-thread")
ArcEye/machinekit-testing
configs/sim/axis/haltest.py
Python
lgpl-2.1
242
0.012397
from typing import TypeVar, Dict, Any from django import template from django.conf import settings from util.getters import reverse_model_url register = template.Library() T = TypeVar('T') @register.filter(name='get_from_dict') def get_from_dict(dictionary: Dict[T, Any], key: T): value = dictionary.get(key) if settings.DEBUG and value is None: print(key, dictionary) return value @register.filter(name='url_finder') def url_finder(obj): return reverse_model_url(obj) @register.filter(name="get_model_url") def get_model_url(obj): return url_finder(obj) @register.filter(name='getattr') def getattrfilter(obj, attr): try: return getattr(obj, attr) except AttributeError: return None
FRC-RS/FRS
TBAW/templatetags/getters.py
Python
mit
750
0
from setuptools import find_packages, setup version = '0.0.1' setup( name='alerta-transient', version=version, description='Example Alerta plugin for transient flapping alerts', url='https://github.com/alerta/alerta-contrib', license='Apache License 2.0', author='Your name', author_email='your.name@example.com', packages=find_packages(), py_modules=['alerta_transient'], install_requires=[], include_package_data=True, zip_safe=True, entry_points={ 'alerta.plugins': [ 'transient = alerta_transient:TransientAlert' ] } )
guardian/alerta
examples/plugins/transient/setup.py
Python
apache-2.0
609
0
# Copyright (c) 2015 Hewlett-Packard Development Company, L.P. # # 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. """ test_port ---------------------------------- Test port resource (managed by neutron) """ from openstack.cloud.exc import OpenStackCloudException from openstack.tests.unit import base class TestPort(base.TestCase): mock_neutron_port_create_rep = { 'port': { 'status': 'DOWN', 'binding:host_id': '', 'name': 'test-port-name', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'test-net-id', 'tenant_id': 'test-tenant-id', 'binding:vif_details': {}, 'binding:vnic_type': 'normal', 'binding:vif_type': 'unbound', 'device_owner': '', 'mac_address': '50:1c:0d:e4:f0:0d', 'binding:profile': {}, 'fixed_ips': [ { 'subnet_id': 'test-subnet-id', 'ip_address': '29.29.29.29' } ], 'id': 'test-port-id', 'security_groups': [], 'device_id': '' } } mock_neutron_port_update_rep = { 'port': { 'status': 'DOWN', 'binding:host_id': '', 'name': 'test-port-name-updated', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'test-net-id', 'tenant_id': 'test-tenant-id', 'binding:vif_details': {}, 'binding:vnic_type': 'normal', 'binding:vif_type': 'unbound', 'device_owner': '', 'mac_address': '50:1c:0d:e4:f0:0d', 'binding:profile': {}, 'fixed_ips': [ { 'subnet_id': 'test-subnet-id', 'ip_address': '29.29.29.29' } ], 'id': 'test-port-id', 'security_groups': [], 'device_id': '' } } mock_neutron_port_list_rep = { 'ports': [ { 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': 'first-port', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': '70c1db1f-b701-45bd-96e0-a313ee3430b3', 'tenant_id': '', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'network:router_gateway', 'mac_address': 'fa:16:3e:58:42:ed', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [ { 'subnet_id': '008ba151-0b8c-4a67-98b5-0d2b87666062', 'ip_address': '172.24.4.2' } ], 'id': 'd80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', 'security_groups': [], 'device_id': '9ae135f4-b6e0-4dad-9e91-3c223e385824' }, { 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': '', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'f27aa545-cbdd-4907-b0c6-c9e8b039dcc2', 'tenant_id': 'd397de8a63f341818f198abb0966f6f3', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'network:router_interface', 'mac_address': 'fa:16:3e:bb:3c:e4', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [ { 'subnet_id': '288bf4a1-51ba-43b6-9d0a-520e9005db17', 'ip_address': '10.0.0.1' } ], 'id': 'f71a6703-d6de-4be1-a91a-a570ede1d159', 'security_groups': [], 'device_id': '9ae135f4-b6e0-4dad-9e91-3c223e385824' } ] } def test_create_port(self): self.register_uris([ dict(method="POST", uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_create_rep, validate=dict( json={'port': { 'network_id': 'test-net-id', 'name': 'test-port-name', 'admin_state_up': True}})) ]) port = self.cloud.create_port( network_id='test-net-id', name='test-port-name', admin_state_up=True) self.assertEqual(self.mock_neutron_port_create_rep['port'], port) self.assert_calls() def test_create_port_parameters(self): """Test that we detect invalid arguments passed to create_port""" self.assertRaises( TypeError, self.cloud.create_port, network_id='test-net-id', nome='test-port-name', stato_amministrativo_porta=True) def test_create_port_exception(self): self.register_uris([ dict(method="POST", uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), status_code=500, validate=dict( json={'port': { 'network_id': 'test-net-id', 'name': 'test-port-name', 'admin_state_up': True}})) ]) self.assertRaises( OpenStackCloudException, self.cloud.create_port, network_id='test-net-id', name='test-port-name', admin_state_up=True) self.assert_calls() def test_update_port(self): port_id = 'd80b1a3b-4fc1-49f3-952e-1e2ab7081d8b' self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep), dict(method='PUT', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports', '%s.json' % port_id]), json=self.mock_neutron_port_update_rep, validate=dict( json={'port': {'name': 'test-port-name-updated'}})) ]) port = self.cloud.update_port( name_or_id=port_id, name='test-port-name-updated') self.assertEqual(self.mock_neutron_port_update_rep['port'], port) self.assert_calls() def test_update_port_parameters(self): """Test that we detect invalid arguments passed to update_port""" self.assertRaises( TypeError, self.cloud.update_port, name_or_id='test-port-id', nome='test-port-name-updated') def test_update_port_exception(self): port_id = 'd80b1a3b-4fc1-49f3-952e-1e2ab7081d8b' self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep), dict(method='PUT', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports', '%s.json' % port_id]), status_code=500, validate=dict( json={'port': {'name': 'test-port-name-updated'}})) ]) self.assertRaises( OpenStackCloudException, self.cloud.update_port, name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', name='test-port-name-updated') self.assert_calls() def test_list_ports(self): self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep) ]) ports = self.cloud.list_ports() self.assertItemsEqual(self.mock_neutron_port_list_rep['ports'], ports) self.assert_calls() def test_list_ports_filtered(self): self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json'], qs_elements=['status=DOWN']), json=self.mock_neutron_port_list_rep) ]) ports = self.cloud.list_ports(filters={'status': 'DOWN'}) self.assertItemsEqual(self.mock_neutron_port_list_rep['ports'], ports) self.assert_calls() def test_list_ports_exception(self): self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), status_code=500) ]) self.assertRaises(OpenStackCloudException, self.cloud.list_ports) def test_search_ports_by_id(self): port_id = 'f71a6703-d6de-4be1-a91a-a570ede1d159' self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep) ]) ports = self.cloud.search_ports(name_or_id=port_id) self.assertEqual(1, len(ports)) self.assertEqual('fa:16:3e:bb:3c:e4', ports[0]['mac_address']) self.assert_calls() def test_search_ports_by_name(self): port_name = "first-port" self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep) ]) ports = self.cloud.search_ports(name_or_id=port_name) self.assertEqual(1, len(ports)) self.assertEqual('fa:16:3e:58:42:ed', ports[0]['mac_address']) self.assert_calls() def test_search_ports_not_found(self): self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep) ]) ports = self.cloud.search_ports(name_or_id='non-existent') self.assertEqual(0, len(ports)) self.assert_calls() def test_delete_port(self): port_id = 'd80b1a3b-4fc1-49f3-952e-1e2ab7081d8b' self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep), dict(method='DELETE', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports', '%s.json' % port_id]), json={}) ]) self.assertTrue(self.cloud.delete_port(name_or_id='first-port')) def test_delete_port_not_found(self): self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json=self.mock_neutron_port_list_rep) ]) self.assertFalse(self.cloud.delete_port(name_or_id='non-existent')) self.assert_calls() def test_delete_subnet_multiple_found(self): port_name = "port-name" port1 = dict(id='123', name=port_name) port2 = dict(id='456', name=port_name) self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json={'ports': [port1, port2]}) ]) self.assertRaises(OpenStackCloudException, self.cloud.delete_port, port_name) self.assert_calls() def test_delete_subnet_multiple_using_id(self): port_name = "port-name" port1 = dict(id='123', name=port_name) port2 = dict(id='456', name=port_name) self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports.json']), json={'ports': [port1, port2]}), dict(method='DELETE', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports', '%s.json' % port1['id']]), json={}) ]) self.assertTrue(self.cloud.delete_port(name_or_id=port1['id'])) self.assert_calls() def test_get_port_by_id(self): fake_port = dict(id='123', name='456') self.register_uris([ dict(method='GET', uri=self.get_mock_url( 'network', 'public', append=['v2.0', 'ports', fake_port['id']]), json={'port': fake_port}) ]) r = self.cloud.get_port_by_id(fake_port['id']) self.assertIsNotNone(r) self.assertDictEqual(fake_port, r) self.assert_calls()
ctrlaltdel/neutrinator
vendor/openstack/tests/unit/cloud/test_port.py
Python
gpl-3.0
14,285
0
# -*- coding: utf-8 -*- #!/usr/bin/env python # # Copyright 2014 BigML # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from world import world from bigml.api import HTTP_OK def i_get_the_project(step, resource): resource = world.api.get_project(resource) world.status = resource['code'] assert world.status == HTTP_OK world.project = resource['object']
ShaguptaS/python
bigml/tests/read_project_steps.py
Python
apache-2.0
869
0.002301
""" @author: Gaetan Hadjeres """ import torch from torch.autograd import Variable def cuda_variable(tensor, volatile=False): if torch.cuda.is_available(): return Variable(tensor.cuda(), volatile=volatile) else: return Variable(tensor, volatile=volatile) def to_numpy(variable: Variable): if torch.cuda.is_available(): return variable.data.cpu().numpy() else: return variable.data.numpy() def init_hidden(num_layers, batch_size, lstm_hidden_size, volatile=False): hidden = ( cuda_variable( torch.randn(num_layers, batch_size, lstm_hidden_size), volatile=volatile), cuda_variable( torch.randn(num_layers, batch_size, lstm_hidden_size), volatile=volatile) ) return hidden
Ghadjeres/DeepBach
DeepBach/helpers.py
Python
mit
816
0
class Resource(object): """Abstract class representing a versioned object""" def __init__(self, identity, revision, repo, isTree): super(Resource, self).__init__() self._id = identity # hash of this object self._revision = revision # revision this object belongs to self._repo = repo # repository this object belongs to def get_latest_revision(self): """Return the last revision this was modified""" raise NotImplementedError def get_properties(self): """Return the properties of a resource""" raise NotImplementedError latest_revision = property(get_latest_revision) properties = property(get_properties)
hbussell/pinax-tracker
apps/pyvcal/git_wrapper/resource.py
Python
mit
719
0.011127
#!/usr/bin/env python # Copyright (c) 2016 Lyft Inc. # # 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 setuptools setuptools.setup( setup_requires=['pbr'], pbr=True)
lyft/bandit-high-entropy-string
setup.py
Python
apache-2.0
680
0
import sys import re # # You must include the following class definition at the top of # your method specification file. # class MethodSpec(object): def __init__(self, name='', source='', class_names='', class_names_compiled=None): """MethodSpec -- A specification of a method. Member variables: name -- The method name source -- The source code for the method. Must be indented to fit in a class definition. class_names -- A regular expression that must match the class names in which the method is to be inserted. class_names_compiled -- The compiled class names. generateDS.py will do this compile for you. """ self.name = name self.source = source if class_names is None: self.class_names = ('.*', ) else: self.class_names = class_names if class_names_compiled is None: self.class_names_compiled = re.compile(self.class_names) else: self.class_names_compiled = class_names_compiled def get_name(self): return self.name def set_name(self, name): self.name = name def get_source(self): return self.source def set_source(self, source): self.source = source def get_class_names(self): return self.class_names def set_class_names(self, class_names): self.class_names = class_names self.class_names_compiled = re.compile(class_names) def get_class_names_compiled(self): return self.class_names_compiled def set_class_names_compiled(self, class_names_compiled): self.class_names_compiled = class_names_compiled def match_name(self, class_name): """Match against the name of the class currently being generated. If this method returns True, the method will be inserted in the generated class. """ if self.class_names_compiled.search(class_name): return True else: return False def get_interpolated_source(self, values_dict): """Get the method source code, interpolating values from values_dict into it. The source returned by this method is inserted into the generated class. """ source = self.source % values_dict return source def show(self): print 'specification:' print ' name: %s' % (self.name, ) print self.source print ' class_names: %s' % (self.class_names, ) print ' names pat : %s' % (self.class_names_compiled.pattern, ) # # Provide one or more method specification such as the following. # Notes: # - Each generated class contains a class variable _member_data_items. # This variable contains a list of instances of class _MemberSpec. # See the definition of class _MemberSpec near the top of the # generated superclass file and also section "User Methods" in # the documentation, as well as the examples below. num_segments = MethodSpec(name='num_segments', source='''\ @property def num_segments(self): return len(self.segments) ''', class_names=("Morphology") ) length = MethodSpec(name='length', source='''\ @property def length(self): prox_x = self.proximal.x prox_y = self.proximal.y prox_z = self.proximal.z dist_x = self.distal.x dist_y = self.distal.y dist_z = self.distal.z length = ((prox_x-dist_x)**2 + (prox_y-dist_y)**2 + (prox_z-dist_z)**2)**(0.5) return length ''', class_names=("Segment") ) volume = MethodSpec(name='volume', source='''\ @property def volume(self): from math import pi prox_diam = self.proximal.diameter dist_diam = self.distal.diameter length = self.length volume = (pi/3)*length*(prox_diam**2+dist_diam**2+prox_diam*dist_diam) return volume ''', class_names=("Segment") ) area = MethodSpec(name='area', source='''\ @property def area(self): from math import pi from math import sqrt prox_diam = self.proximal.diameter dist_diam = self.distal.diameter length = self.length area = pi*(prox_diam+dist_diam)*sqrt((prox_diam-dist_diam)**2+length**2) return area ''', class_names=("Segment") ) # # Provide a list of your method specifications. # This list of specifications must be named METHOD_SPECS. # METHOD_SPECS=(length, volume, area, num_segments, ) def test(): for spec in METHOD_SPECS: spec.show() def main(): test() if __name__ == '__main__': main()
joebowen/movement_validation_cloud
djangodev/lib/python2.7/site-packages/neuroml/nml/helper_methods.py
Python
mit
4,806
0.005826
# -*- coding: utf-8 -*- ## \package custom # MIT licensing # See: LICENSE.txt
AntumDeluge/desktop_recorder
source/custom/__init__.py
Python
mit
80
0.0125
#!/usr/bin/env python # # Copyright 2015 clowwindy # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from __future__ import absolute_import, division, print_function, \ with_statement from ctypes import c_char_p, c_int, c_long, byref,\ create_string_buffer, c_void_p from shadowsocks import common from shadowsocks.crypto import util __all__ = ['ciphers'] libcrypto = None loaded = False buf_size = 2048 def load_openssl(): global loaded, libcrypto, buf libcrypto = util.find_library(('crypto', 'eay32'), 'EVP_get_cipherbyname', 'libcrypto') if libcrypto is None: raise Exception('libcrypto(OpenSSL) not found') libcrypto.EVP_get_cipherbyname.restype = c_void_p libcrypto.EVP_CIPHER_CTX_new.restype = c_void_p libcrypto.EVP_CipherInit_ex.argtypes = (c_void_p, c_void_p, c_char_p, c_char_p, c_char_p, c_int) libcrypto.EVP_CipherUpdate.argtypes = (c_void_p, c_void_p, c_void_p, c_char_p, c_int) libcrypto.EVP_CIPHER_CTX_cleanup.argtypes = (c_void_p,) libcrypto.EVP_CIPHER_CTX_free.argtypes = (c_void_p,) if hasattr(libcrypto, 'OpenSSL_add_all_ciphers'): libcrypto.OpenSSL_add_all_ciphers() buf = create_string_buffer(buf_size) loaded = True def load_cipher(cipher_name): func_name = 'EVP_' + cipher_name.replace('-', '_') if bytes != str: func_name = str(func_name, 'utf-8') cipher = getattr(libcrypto, func_name, None) if cipher: cipher.restype = c_void_p return cipher() return None class OpenSSLCrypto(object): def __init__(self, cipher_name, key, iv, op): self._ctx = None if not loaded: load_openssl() cipher_name = common.to_bytes(cipher_name) cipher = libcrypto.EVP_get_cipherbyname(cipher_name) if not cipher: cipher = load_cipher(cipher_name) if not cipher: raise Exception('cipher %s not found in libcrypto' % cipher_name) key_ptr = c_char_p(key) iv_ptr = c_char_p(iv) self._ctx = libcrypto.EVP_CIPHER_CTX_new() if not self._ctx: raise Exception('can not create cipher context') r = libcrypto.EVP_CipherInit_ex(self._ctx, cipher, None, key_ptr, iv_ptr, c_int(op)) if not r: self.clean() raise Exception('can not initialize cipher context') def update(self, data): global buf_size, buf cipher_out_len = c_long(0) l = len(data) if buf_size < l: buf_size = l * 2 buf = create_string_buffer(buf_size) libcrypto.EVP_CipherUpdate(self._ctx, byref(buf), byref(cipher_out_len), c_char_p(data), l) # buf is copied to a str object when we access buf.raw return buf.raw[:cipher_out_len.value] def __del__(self): self.clean() def clean(self): if self._ctx: libcrypto.EVP_CIPHER_CTX_cleanup(self._ctx) libcrypto.EVP_CIPHER_CTX_free(self._ctx) ciphers = { 'aes-128-cfb': (16, 16, OpenSSLCrypto), 'aes-192-cfb': (24, 16, OpenSSLCrypto), 'aes-256-cfb': (32, 16, OpenSSLCrypto), 'aes-128-ofb': (16, 16, OpenSSLCrypto), 'aes-192-ofb': (24, 16, OpenSSLCrypto), 'aes-256-ofb': (32, 16, OpenSSLCrypto), 'aes-128-ctr': (16, 16, OpenSSLCrypto), 'aes-192-ctr': (24, 16, OpenSSLCrypto), 'aes-256-ctr': (32, 16, OpenSSLCrypto), 'aes-128-cfb8': (16, 16, OpenSSLCrypto), 'aes-192-cfb8': (24, 16, OpenSSLCrypto), 'aes-256-cfb8': (32, 16, OpenSSLCrypto), 'aes-128-cfb1': (16, 16, OpenSSLCrypto), 'aes-192-cfb1': (24, 16, OpenSSLCrypto), 'aes-256-cfb1': (32, 16, OpenSSLCrypto), 'bf-cfb': (16, 8, OpenSSLCrypto), 'camellia-128-cfb': (16, 16, OpenSSLCrypto), 'camellia-192-cfb': (24, 16, OpenSSLCrypto), 'camellia-256-cfb': (32, 16, OpenSSLCrypto), 'cast5-cfb': (16, 8, OpenSSLCrypto), 'des-cfb': (8, 8, OpenSSLCrypto), 'idea-cfb': (16, 8, OpenSSLCrypto), 'rc2-cfb': (16, 8, OpenSSLCrypto), 'rc4': (16, 0, OpenSSLCrypto), 'seed-cfb': (16, 16, OpenSSLCrypto), } def run_method(method): cipher = OpenSSLCrypto(method, b'k' * 32, b'i' * 16, 1) decipher = OpenSSLCrypto(method, b'k' * 32, b'i' * 16, 0) util.run_cipher(cipher, decipher) def test_aes_128_cfb(): run_method('aes-128-cfb') def test_aes_256_cfb(): run_method('aes-256-cfb') def test_aes_128_cfb8(): run_method('aes-128-cfb8') def test_aes_256_ofb(): run_method('aes-256-ofb') def test_aes_256_ctr(): run_method('aes-256-ctr') def test_bf_cfb(): run_method('bf-cfb') def test_rc4(): run_method('rc4') if __name__ == '__main__': test_aes_128_cfb()
Ju2ender/CSharp-Exercise
shadowsocks/shadowsocks/crypto/openssl.py
Python
mit
5,414
0.000185
''' Created on Oct 18, 2016 @author: Vitoc ''' import copy class undoModuleClass: def __init__(self): return ''' Function that undos the operations that you have made ''' def saveTheFunction(self,l,undo): undo.append(copy.deepcopy(l)) def undoIntoPast(self,l,undo): try: maximus = len(undo) -1 l = copy.deepcopy(undo[maximus]) del undo[maximus] except IndexError: print("There are no more undos , sry") return l
valecs97/Contest
Contest/iteration_3/undoModule.py
Python
gpl-3.0
593
0.026981
# -*- coding: utf-8 -*- # This file is part of Knitlib. # # Knitlib is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Knitlib is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Knitlib. If not, see <http://www.gnu.org/licenses/>. # # Copyright 2015 Sebastian Oliva <http://github.com/fashiontec/knitlib> import logging import time import knitting_plugin class DummyKnittingPlugin(knitting_plugin.BaseKnittingPlugin): """Implements a sample knitting plugin that allows for simple operation emulation.""" __PLUGIN_NAME__ = u"dummy" def __init__(self): super(DummyKnittingPlugin, self).__init__() base_log_string = u"{} has been called on dummy knitting plugin." def onknit(self, e): logging.debug(DummyKnittingPlugin.base_log_string.format("onknit")) # In order to simulate blocking we make it sleep. total = 5 for i in range(total): time.sleep(1) self.interactive_callbacks["progress"](i / float(total), i, total) self.finish() def onfinish(self, e): logging.debug(DummyKnittingPlugin.base_log_string.format("onfinish")) def onconfigure(self, e): logging.debug(DummyKnittingPlugin.base_log_string.format("onconfigure")) def set_port(self, *args, **kwargs): pass @staticmethod def supported_config_features(): return {"$schema": "http://json-schema.org/schema#", "type": "object"}
fashiontec/knitlib
src/knitlib/plugins/dummy_plugin.py
Python
lgpl-3.0
1,842
0.007058
#!/usr/bin/env python """ Copyright 2012 GroupDocs. 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. """ class State: """ NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually.""" def __init__(self): self.swaggerTypes = { }
liosha2007/temporary-groupdocs-python3-sdk
groupdocs/models/State.py
Python
apache-2.0
851
0.005875
# encoding: utf-8 """ Rules system. """ import copy from operator import itemgetter class RuleBase(object): """ All rules inherit from RuleBase. All rules needs a condition, a response. RuleBase is the base model to all rules. with this class, the rules will can to access to the main class (Gozokia), the sentence (the input), and/or the analyzer (if it is active) """ completed = False reload = True response_output = "" print_output = "" def __init__(self): self.set_reload(False) def condition_raise(self, *args, **kwargs): self.gozokia = kwargs.get('gozokia') self.analyzer = self.gozokia.analyzer self.sentence = self.gozokia.sentence def condition_completed(self, *args, **kwargs): self.gozokia = kwargs.get('gozokia') self.analyzer = self.gozokia.analyzer self.sentence = self.gozokia.sentence def response(self, *args, **kwargs): raise NotImplementedError(__class__.__name__ + ": response not defined") def get_response(self, *args, **kwargs): self.response(*args, **kwargs) return self.response_output, self.print_output def is_completed(self, *args, **kwargs): return self.completed def set_completed(self, status=True): self.completed = status def set_reload(self, reload): self.reload = reload def reload_rule(self): if self.reload: self.set_completed(False) return True else: return False def __str__(self): return self.__class__.__name__ class Rules(object): __rules_pool = [] __rules_map = {} __rules_qeue = [] __rules_qeue_completed = [] __active_rule = None _STATUS_RULES_KEY = "status" _STATUS_RULES = (0, 1, 2) _STATUS_RULE_COMPLETED = 0 _STATUS_RULE_PENDING = 1 _STATUS_RULE_ACTIVE = 2 _RAISE_COND = 1 _OBJETIVE_COND = 2 __RULE_KEY_CLASS = "class" __RULE_KEY_NAME = "rule" def __init__(self, * args, **kwargs): self.session_id = kwargs['sessionid'] # Set the session to for rule_pool in self.__rules_pool: rule_pool['session'] = self.session_id self.__rules_map[self.session_id] = [] self._rules_completed = self.__rules_map[self.session_id] self.__rules_map[self.session_id] = self.__rules_pool self.__rules_qeue = self.__rules_map[self.session_id] """ self.__rules_qeue = copy.copy(self.__rules_pool) """ def add(self, rule_class, **options): rank = 10 type_rule = None rule_object = rule_class() if 'rank' in options and type(options['rank']) is int: rank = options['rank'] if 'type' in options and type(options['type']) is int: type_rule = options['type'] if 'name' in options and type(options['name']) is str: rule_name = options['name'] else: rule_name = str(rule_object) # Session is none because "add" method is a decorator. When this method is executed # the init method not exist if rule_name not in set(r['rule'] for r in self.__rules_pool): self.__rules_pool.append({'session': None, 'rule': rule_name, self.__RULE_KEY_CLASS: copy.copy(rule_object), 'rank': rank, 'type': type_rule, self._STATUS_RULES_KEY: self._STATUS_RULE_PENDING}) def get_rules(self, type_rule=None): """ return a diccionary of rules order by rank and filter by type or fule """ f = lambda x: True if type_rule in [self._RAISE_COND, self._OBJETIVE_COND]: f = lambda x: x['type'] == type_rule and x[self.__RULE_KEY_CLASS].completed == False return sorted(filter(f, self.__rules_qeue), key=itemgetter('rank')) def get_rules_completed(self): return sorted(self.__rules_qeue_completed, key=itemgetter('rank')) def get_raises(self): for rule in self.get_rules(type_rule=self._RAISE_COND): yield rule def get_objetives(self): for rule in self.get_rules(type_rule=self._OBJETIVE_COND): yield rule def get_rule(self, gozokia): """ Get the active rule or find one. """ if self.exist_active_rule(): active_rule_object = self.get_active_rule().get(self.__RULE_KEY_CLASS) active_rule_object.condition_completed(gozokia=gozokia) if active_rule_object.is_completed(): self.complete_active_rule() self.get_rule(gozokia=gozokia) else: for r in self: if r.get(self.__RULE_KEY_CLASS).condition_raise(gozokia=gozokia): self.set_active_rule(r) break return self.__active_rule def eval(self, gozokia): response_output = None print_output = None rule = self.get_rule(gozokia) if rule: active_rule_object = rule.get(self.__RULE_KEY_CLASS) response_output, print_output = active_rule_object.get_response() active_rule_object.condition_completed(gozokia=gozokia) if active_rule_object.is_completed(): self.complete_active_rule() return rule, response_output, print_output def set_rule_status_active(self, rule): print("RULE {} start".format(rule.get(self.__RULE_KEY_NAME))) rule[self._STATUS_RULES_KEY] = self._STATUS_RULE_ACTIVE self.set_active_rule(None) def set_rule_status_pending(self, rule): print("RULE {} pending".format(rule.get(self.__RULE_KEY_NAME))) rule[self._STATUS_RULES_KEY] = self._STATUS_RULE_PENDING def set_rule_status_completed(self, rule): print("RULE {} completed".format(rule.get(self.__RULE_KEY_NAME))) rule[self._STATUS_RULES_KEY] = self._STATUS_RULE_COMPLETED def complete_active_rule(self): rule = self.get_active_rule() self.set_rule_completed(rule) self.set_active_rule(None) def set_rule_completed(self, rule): self.set_rule_status_completed(rule) if rule.get(self.__RULE_KEY_CLASS).reload_rule() is False: self.pop(rule) def set_rule_pending(self, rule): self.set_rule_status_pending(rule) def get_active_rule(self, key=None): if key is None: rule = self.__active_rule else: rule = self.__active_rule[key] return rule def set_active_rule(self, rule=None): if rule: self.set_rule_status_active(rule) self.__active_rule = rule def stop_active_rule(self): self.set_rule_status_pending(self.__active_rule) self.set_active_rule(None) def exist_active_rule(self): return self.__active_rule is not None def pop(self, rule): # Pop rule from main queue self.__rules_qeue = [r for r in self if r.get(self.__RULE_KEY_CLASS) != rule.get(self.__RULE_KEY_CLASS)] # Add rule to completed queue if rule.get(self.__RULE_KEY_CLASS) not in set(r.get(rule.get(self.__RULE_KEY_CLASS)) for r in self.__rules_qeue_completed): self.__rules_qeue_completed.append(rule) def __getitem__(self, key): if key in self.__rules_qeue: return self.__rules_qeue[key] raise KeyError def __iter__(self): for rule in self.get_rules(): yield rule
avara1986/gozokia
gozokia/core/rules.py
Python
mit
7,566
0.001718
# Copyright (c) 2014 Cisco Systems, Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import copy import mock from oslo_utils.fixture import uuidsentinel from oslo_utils import uuidutils import six import webob from nova.api.openstack import api_version_request as avr from nova.api.openstack.compute import server_groups as sg_v21 from nova import context from nova import exception from nova import objects from nova.policies import server_groups as sg_policies from nova import test from nova.tests import fixtures from nova.tests.unit.api.openstack import fakes from nova.tests.unit import policy_fixture class AttrDict(dict): def __getattr__(self, k): return self[k] def server_group_template(**kwargs): sgroup = kwargs.copy() sgroup.setdefault('name', 'test') return sgroup def server_group_resp_template(**kwargs): sgroup = kwargs.copy() sgroup.setdefault('name', 'test') if 'policy' not in kwargs: sgroup.setdefault('policies', []) sgroup.setdefault('members', []) return sgroup def server_group_db(sg): attrs = copy.deepcopy(sg) if 'id' in attrs: attrs['uuid'] = attrs.pop('id') if 'policies' in attrs: policies = attrs.pop('policies') attrs['policies'] = policies else: attrs['policies'] = [] if 'policy' in attrs: del attrs['policies'] if 'members' in attrs: members = attrs.pop('members') attrs['members'] = members else: attrs['members'] = [] attrs['deleted'] = 0 attrs['deleted_at'] = None attrs['created_at'] = None attrs['updated_at'] = None if 'user_id' not in attrs: attrs['user_id'] = fakes.FAKE_USER_ID if 'project_id' not in attrs: attrs['project_id'] = fakes.FAKE_PROJECT_ID attrs['id'] = 7 return AttrDict(attrs) class ServerGroupTestV21(test.NoDBTestCase): USES_DB_SELF = True validation_error = exception.ValidationError def setUp(self): super(ServerGroupTestV21, self).setUp() self._setup_controller() self.req = fakes.HTTPRequest.blank('') self.admin_req = fakes.HTTPRequest.blank('', use_admin_context=True) self.foo_req = fakes.HTTPRequest.blank('', project_id='foo') self.policy = self.useFixture(policy_fixture.RealPolicyFixture()) self.useFixture(fixtures.Database(database='api')) cells = fixtures.CellDatabases() cells.add_cell_database(uuidsentinel.cell1) cells.add_cell_database(uuidsentinel.cell2) self.useFixture(cells) ctxt = context.get_admin_context() self.cells = {} for uuid in (uuidsentinel.cell1, uuidsentinel.cell2): cm = objects.CellMapping(context=ctxt, uuid=uuid, database_connection=uuid, transport_url=uuid) cm.create() self.cells[cm.uuid] = cm def _setup_controller(self): self.controller = sg_v21.ServerGroupController() def test_create_server_group_with_no_policies(self): sgroup = server_group_template() self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) def _create_server_group_normal(self, policies=None, policy=None, rules=None): sgroup = server_group_template() sgroup['policies'] = policies res_dict = self.controller.create(self.req, body={'server_group': sgroup}) self.assertEqual(res_dict['server_group']['name'], 'test') self.assertTrue(uuidutils.is_uuid_like(res_dict['server_group']['id'])) self.assertEqual(res_dict['server_group']['policies'], policies) def test_create_server_group_with_new_policy_before_264(self): req = fakes.HTTPRequest.blank('', version='2.63') policy = 'anti-affinity' rules = {'max_server_per_host': 3} # 'policy' isn't an acceptable request key before 2.64 sgroup = server_group_template(policy=policy) result = self.assertRaises( self.validation_error, self.controller.create, req, body={'server_group': sgroup}) self.assertIn( "Invalid input for field/attribute server_group", six.text_type(result) ) # 'rules' isn't an acceptable request key before 2.64 sgroup = server_group_template(rules=rules) result = self.assertRaises( self.validation_error, self.controller.create, req, body={'server_group': sgroup}) self.assertIn( "Invalid input for field/attribute server_group", six.text_type(result) ) def test_create_server_group(self): policies = ['affinity', 'anti-affinity'] for policy in policies: self._create_server_group_normal(policies=[policy]) def test_create_server_group_rbac_default(self): sgroup = server_group_template() sgroup['policies'] = ['affinity'] # test as admin self.controller.create(self.admin_req, body={'server_group': sgroup}) # test as non-admin self.controller.create(self.req, body={'server_group': sgroup}) def test_create_server_group_rbac_admin_only(self): sgroup = server_group_template() sgroup['policies'] = ['affinity'] # override policy to restrict to admin rule_name = sg_policies.POLICY_ROOT % 'create' rules = {rule_name: 'is_admin:True'} self.policy.set_rules(rules, overwrite=False) # check for success as admin self.controller.create(self.admin_req, body={'server_group': sgroup}) # check for failure as non-admin exc = self.assertRaises(exception.PolicyNotAuthorized, self.controller.create, self.req, body={'server_group': sgroup}) self.assertEqual( "Policy doesn't allow %s to be performed." % rule_name, exc.format_message()) def _create_instance(self, ctx, cell): with context.target_cell(ctx, cell) as cctx: instance = objects.Instance(context=cctx, image_ref=uuidsentinel.fake_image_ref, node='node1', reservation_id='a', host='host1', project_id='fake', vm_state='fake', system_metadata={'key': 'value'}) instance.create() im = objects.InstanceMapping(context=ctx, project_id=ctx.project_id, user_id=ctx.user_id, cell_mapping=cell, instance_uuid=instance.uuid) im.create() return instance def _create_instance_group(self, context, members): ig = objects.InstanceGroup(context=context, name='fake_name', user_id='fake_user', project_id='fake', members=members) ig.create() return ig.uuid def _create_groups_and_instances(self, ctx): cell1 = self.cells[uuidsentinel.cell1] cell2 = self.cells[uuidsentinel.cell2] instances = [self._create_instance(ctx, cell=cell1), self._create_instance(ctx, cell=cell2), self._create_instance(ctx, cell=None)] members = [instance.uuid for instance in instances] ig_uuid = self._create_instance_group(ctx, members) return (ig_uuid, instances, members) def _test_list_server_group_all(self, api_version='2.1'): self._test_list_server_group(api_version=api_version, limited='', path='/os-server-groups?all_projects=True') def _test_list_server_group_offset_and_limit(self, api_version='2.1'): self._test_list_server_group(api_version=api_version, limited='&offset=1&limit=1', path='/os-server-groups?all_projects=True') @mock.patch('nova.objects.InstanceGroupList.get_by_project_id') @mock.patch('nova.objects.InstanceGroupList.get_all') def _test_list_server_group(self, mock_get_all, mock_get_by_project, path, api_version='2.1', limited=None): policies = ['anti-affinity'] policy = "anti-affinity" members = [] metadata = {} # always empty names = ['default-x', 'test'] p_id = fakes.FAKE_PROJECT_ID u_id = fakes.FAKE_USER_ID ver = avr.APIVersionRequest(api_version) if ver >= avr.APIVersionRequest("2.64"): sg1 = server_group_resp_template(id=uuidsentinel.sg1_id, name=names[0], policy=policy, rules={}, members=members, project_id=p_id, user_id=u_id) sg2 = server_group_resp_template(id=uuidsentinel.sg2_id, name=names[1], policy=policy, rules={}, members=members, project_id=p_id, user_id=u_id) elif ver >= avr.APIVersionRequest("2.13"): sg1 = server_group_resp_template(id=uuidsentinel.sg1_id, name=names[0], policies=policies, members=members, metadata=metadata, project_id=p_id, user_id=u_id) sg2 = server_group_resp_template(id=uuidsentinel.sg2_id, name=names[1], policies=policies, members=members, metadata=metadata, project_id=p_id, user_id=u_id) else: sg1 = server_group_resp_template(id=uuidsentinel.sg1_id, name=names[0], policies=policies, members=members, metadata=metadata) sg2 = server_group_resp_template(id=uuidsentinel.sg2_id, name=names[1], policies=policies, members=members, metadata=metadata) tenant_groups = [sg2] all_groups = [sg1, sg2] if limited: all = {'server_groups': [sg2]} tenant_specific = {'server_groups': []} else: all = {'server_groups': all_groups} tenant_specific = {'server_groups': tenant_groups} def return_all_server_groups(): return objects.InstanceGroupList( objects=[objects.InstanceGroup( **server_group_db(sg)) for sg in all_groups]) mock_get_all.return_value = return_all_server_groups() def return_tenant_server_groups(): return objects.InstanceGroupList( objects=[objects.InstanceGroup( **server_group_db(sg)) for sg in tenant_groups]) mock_get_by_project.return_value = return_tenant_server_groups() path = '/os-server-groups?all_projects=True' if limited: path += limited req = fakes.HTTPRequest.blank(path, version=api_version) admin_req = fakes.HTTPRequest.blank(path, use_admin_context=True, version=api_version) # test as admin res_dict = self.controller.index(admin_req) self.assertEqual(all, res_dict) # test as non-admin res_dict = self.controller.index(req) self.assertEqual(tenant_specific, res_dict) @mock.patch('nova.objects.InstanceGroupList.get_by_project_id') def _test_list_server_group_by_tenant(self, mock_get_by_project, api_version='2.1'): policies = ['anti-affinity'] members = [] metadata = {} # always empty names = ['default-x', 'test'] p_id = fakes.FAKE_PROJECT_ID u_id = fakes.FAKE_USER_ID if api_version >= '2.13': sg1 = server_group_resp_template(id=uuidsentinel.sg1_id, name=names[0], policies=policies, members=members, metadata=metadata, project_id=p_id, user_id=u_id) sg2 = server_group_resp_template(id=uuidsentinel.sg2_id, name=names[1], policies=policies, members=members, metadata=metadata, project_id=p_id, user_id=u_id) else: sg1 = server_group_resp_template(id=uuidsentinel.sg1_id, name=names[0], policies=policies, members=members, metadata=metadata) sg2 = server_group_resp_template(id=uuidsentinel.sg2_id, name=names[1], policies=policies, members=members, metadata=metadata) groups = [sg1, sg2] expected = {'server_groups': groups} def return_server_groups(): return objects.InstanceGroupList( objects=[objects.InstanceGroup( **server_group_db(sg)) for sg in groups]) return_get_by_project = return_server_groups() mock_get_by_project.return_value = return_get_by_project path = '/os-server-groups' req = fakes.HTTPRequest.blank(path, version=api_version) res_dict = self.controller.index(req) self.assertEqual(expected, res_dict) def test_display_members(self): ctx = context.RequestContext('fake_user', 'fake') (ig_uuid, instances, members) = self._create_groups_and_instances(ctx) res_dict = self.controller.show(self.req, ig_uuid) result_members = res_dict['server_group']['members'] self.assertEqual(3, len(result_members)) for member in members: self.assertIn(member, result_members) def test_display_members_with_nonexistent_group(self): self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, self.req, uuidsentinel.group) def test_display_active_members_only(self): ctx = context.RequestContext('fake_user', 'fake') (ig_uuid, instances, members) = self._create_groups_and_instances(ctx) # delete an instance im = objects.InstanceMapping.get_by_instance_uuid(ctx, instances[1].uuid) with context.target_cell(ctx, im.cell_mapping) as cctxt: instances[1]._context = cctxt instances[1].destroy() # check that the instance does not exist self.assertRaises(exception.InstanceNotFound, objects.Instance.get_by_uuid, ctx, instances[1].uuid) res_dict = self.controller.show(self.req, ig_uuid) result_members = res_dict['server_group']['members'] # check that only the active instance is displayed self.assertEqual(2, len(result_members)) self.assertIn(instances[0].uuid, result_members) def test_display_members_rbac_default(self): ctx = context.RequestContext('fake_user', 'fake') ig_uuid = self._create_groups_and_instances(ctx)[0] # test as admin self.controller.show(self.admin_req, ig_uuid) # test as non-admin, same project self.controller.show(self.req, ig_uuid) # test as non-admin, different project self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, self.foo_req, ig_uuid) def test_display_members_rbac_admin_only(self): ctx = context.RequestContext('fake_user', 'fake') ig_uuid = self._create_groups_and_instances(ctx)[0] # override policy to restrict to admin rule_name = sg_policies.POLICY_ROOT % 'show' rules = {rule_name: 'is_admin:True'} self.policy.set_rules(rules, overwrite=False) # check for success as admin self.controller.show(self.admin_req, ig_uuid) # check for failure as non-admin exc = self.assertRaises(exception.PolicyNotAuthorized, self.controller.show, self.req, ig_uuid) self.assertEqual( "Policy doesn't allow %s to be performed." % rule_name, exc.format_message()) def test_create_server_group_with_non_alphanumeric_in_name(self): # The fix for bug #1434335 expanded the allowable character set # for server group names to include non-alphanumeric characters # if they are printable. sgroup = server_group_template(name='good* $%name', policies=['affinity']) res_dict = self.controller.create(self.req, body={'server_group': sgroup}) self.assertEqual(res_dict['server_group']['name'], 'good* $%name') def test_create_server_group_with_illegal_name(self): # blank name sgroup = server_group_template(name='', policies=['test_policy']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # name with length 256 sgroup = server_group_template(name='1234567890' * 26, policies=['test_policy']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # non-string name sgroup = server_group_template(name=12, policies=['test_policy']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # name with leading spaces sgroup = server_group_template(name=' leading spaces', policies=['test_policy']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # name with trailing spaces sgroup = server_group_template(name='trailing space ', policies=['test_policy']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # name with all spaces sgroup = server_group_template(name=' ', policies=['test_policy']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # name with unprintable character sgroup = server_group_template(name='bad\x00name', policies=['test_policy']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # name with out of range char U0001F4A9 sgroup = server_group_template(name=u"\U0001F4A9", policies=['affinity']) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) def test_create_server_group_with_illegal_policies(self): # blank policy sgroup = server_group_template(name='fake-name', policies='') self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # policy as integer sgroup = server_group_template(name='fake-name', policies=7) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # policy as string sgroup = server_group_template(name='fake-name', policies='invalid') self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) # policy as None sgroup = server_group_template(name='fake-name', policies=None) self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) def test_create_server_group_conflicting_policies(self): sgroup = server_group_template() policies = ['anti-affinity', 'affinity'] sgroup['policies'] = policies self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) def test_create_server_group_with_duplicate_policies(self): sgroup = server_group_template() policies = ['affinity', 'affinity'] sgroup['policies'] = policies self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) def test_create_server_group_not_supported(self): sgroup = server_group_template() policies = ['storage-affinity', 'anti-affinity', 'rack-affinity'] sgroup['policies'] = policies self.assertRaises(self.validation_error, self.controller.create, self.req, body={'server_group': sgroup}) def test_create_server_group_with_no_body(self): self.assertRaises(self.validation_error, self.controller.create, self.req, body=None) def test_create_server_group_with_no_server_group(self): body = {'no-instanceGroup': None} self.assertRaises(self.validation_error, self.controller.create, self.req, body=body) def test_list_server_group_by_tenant(self): self._test_list_server_group_by_tenant(api_version='2.1') def test_list_server_group_all_v20(self): self._test_list_server_group_all(api_version='2.0') def test_list_server_group_all(self): self._test_list_server_group_all(api_version='2.1') def test_list_server_group_offset_and_limit(self): self._test_list_server_group_offset_and_limit(api_version='2.1') def test_list_server_groups_rbac_default(self): # test as admin self.controller.index(self.admin_req) # test as non-admin self.controller.index(self.req) def test_list_server_group_multiple_param(self): self._test_list_server_group(api_version='2.1', limited='&offset=2&limit=2&limit=1&offset=1', path='/os-server-groups?all_projects=False&all_projects=True') def test_list_server_group_additional_param(self): self._test_list_server_group(api_version='2.1', limited='&offset=1&limit=1', path='/os-server-groups?dummy=False&all_projects=True') def test_list_server_group_param_as_int(self): self._test_list_server_group(api_version='2.1', limited='&offset=1&limit=1', path='/os-server-groups?all_projects=1') def test_list_server_group_negative_int_as_offset(self): self.assertRaises(exception.ValidationError, self._test_list_server_group, api_version='2.1', limited='&offset=-1', path='/os-server-groups?all_projects=1') def test_list_server_group_string_int_as_offset(self): self.assertRaises(exception.ValidationError, self._test_list_server_group, api_version='2.1', limited='&offset=dummy', path='/os-server-groups?all_projects=1') def test_list_server_group_multiparam_string_as_offset(self): self.assertRaises(exception.ValidationError, self._test_list_server_group, api_version='2.1', limited='&offset=dummy&offset=1', path='/os-server-groups?all_projects=1') def test_list_server_group_negative_int_as_limit(self): self.assertRaises(exception.ValidationError, self._test_list_server_group, api_version='2.1', limited='&limit=-1', path='/os-server-groups?all_projects=1') def test_list_server_group_string_int_as_limit(self): self.assertRaises(exception.ValidationError, self._test_list_server_group, api_version='2.1', limited='&limit=dummy', path='/os-server-groups?all_projects=1') def test_list_server_group_multiparam_string_as_limit(self): self.assertRaises(exception.ValidationError, self._test_list_server_group, api_version='2.1', limited='&limit=dummy&limit=1', path='/os-server-groups?all_projects=1') def test_list_server_groups_rbac_admin_only(self): # override policy to restrict to admin rule_name = sg_policies.POLICY_ROOT % 'index' rules = {rule_name: 'is_admin:True'} self.policy.set_rules(rules, overwrite=False) # check for success as admin self.controller.index(self.admin_req) # check for failure as non-admin exc = self.assertRaises(exception.PolicyNotAuthorized, self.controller.index, self.req) self.assertEqual( "Policy doesn't allow %s to be performed." % rule_name, exc.format_message()) @mock.patch('nova.objects.InstanceGroup.destroy') def test_delete_server_group_by_id(self, mock_destroy): sg = server_group_template(id=uuidsentinel.sg1_id) def return_server_group(_cls, context, group_id): self.assertEqual(sg['id'], group_id) return objects.InstanceGroup(**server_group_db(sg)) self.stub_out('nova.objects.InstanceGroup.get_by_uuid', return_server_group) resp = self.controller.delete(self.req, uuidsentinel.sg1_id) mock_destroy.assert_called_once_with() # NOTE: on v2.1, http status code is set as wsgi_code of API # method instead of status_int in a response object. if isinstance(self.controller, sg_v21.ServerGroupController): status_int = self.controller.delete.wsgi_code else: status_int = resp.status_int self.assertEqual(204, status_int) def test_delete_non_existing_server_group(self): self.assertRaises(webob.exc.HTTPNotFound, self.controller.delete, self.req, 'invalid') def test_delete_server_group_rbac_default(self): ctx = context.RequestContext('fake_user', 'fake') # test as admin ig_uuid = self._create_groups_and_instances(ctx)[0] self.controller.delete(self.admin_req, ig_uuid) # test as non-admin ig_uuid = self._create_groups_and_instances(ctx)[0] self.controller.delete(self.req, ig_uuid) def test_delete_server_group_rbac_admin_only(self): ctx = context.RequestContext('fake_user', 'fake') # override policy to restrict to admin rule_name = sg_policies.POLICY_ROOT % 'delete' rules = {rule_name: 'is_admin:True'} self.policy.set_rules(rules, overwrite=False) # check for success as admin ig_uuid = self._create_groups_and_instances(ctx)[0] self.controller.delete(self.admin_req, ig_uuid) # check for failure as non-admin ig_uuid = self._create_groups_and_instances(ctx)[0] exc = self.assertRaises(exception.PolicyNotAuthorized, self.controller.delete, self.req, ig_uuid) self.assertEqual( "Policy doesn't allow %s to be performed." % rule_name, exc.format_message()) class ServerGroupTestV213(ServerGroupTestV21): wsgi_api_version = '2.13' def _setup_controller(self): self.controller = sg_v21.ServerGroupController() def test_list_server_group_all(self): self._test_list_server_group_all(api_version='2.13') def test_list_server_group_offset_and_limit(self): self._test_list_server_group_offset_and_limit(api_version='2.13') def test_list_server_group_by_tenant(self): self._test_list_server_group_by_tenant(api_version='2.13') class ServerGroupTestV264(ServerGroupTestV213): wsgi_api_version = '2.64' def _setup_controller(self): self.controller = sg_v21.ServerGroupController() def _create_server_group_normal(self, policies=None, policy=None, rules=None): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) sgroup = server_group_template() sgroup['rules'] = rules or {} sgroup['policy'] = policy res_dict = self.controller.create(req, body={'server_group': sgroup}) self.assertEqual(res_dict['server_group']['name'], 'test') self.assertTrue(uuidutils.is_uuid_like(res_dict['server_group']['id'])) self.assertEqual(res_dict['server_group']['policy'], policy) self.assertEqual(res_dict['server_group']['rules'], rules or {}) return res_dict['server_group']['id'] def test_list_server_group_all(self): self._test_list_server_group_all(api_version=self.wsgi_api_version) def test_create_and_show_server_group(self): policies = ['affinity', 'anti-affinity'] for policy in policies: g_uuid = self._create_server_group_normal( policy=policy) res_dict = self._display_server_group(g_uuid) self.assertEqual(res_dict['server_group']['policy'], policy) self.assertEqual(res_dict['server_group']['rules'], {}) def _display_server_group(self, uuid): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) group = self.controller.show(req, uuid) return group @mock.patch('nova.objects.service.get_minimum_version_all_cells', return_value=33) def test_create_and_show_server_group_with_rules(self, mock_get_v): policy = 'anti-affinity' rules = {'max_server_per_host': 3} g_uuid = self._create_server_group_normal( policy=policy, rules=rules) res_dict = self._display_server_group(g_uuid) self.assertEqual(res_dict['server_group']['policy'], policy) self.assertEqual(res_dict['server_group']['rules'], rules) def test_create_affinity_server_group_with_invalid_policy(self): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) sgroup = server_group_template(policy='affinity', rules={'max_server_per_host': 3}) result = self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create, req, body={'server_group': sgroup}) self.assertIn("Only anti-affinity policy supports rules", six.text_type(result)) def test_create_anti_affinity_server_group_with_invalid_rules(self): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) # A negative test for key is unknown, the value is not positive # and not integer invalid_rules = [{'unknown_key': '3'}, {'max_server_per_host': 0}, {'max_server_per_host': 'foo'}] for r in invalid_rules: sgroup = server_group_template(policy='anti-affinity', rules=r) result = self.assertRaises( self.validation_error, self.controller.create, req, body={'server_group': sgroup}) self.assertIn( "Invalid input for field/attribute", six.text_type(result) ) @mock.patch('nova.objects.service.get_minimum_version_all_cells', return_value=32) def test_create_server_group_with_low_version_compute_service(self, mock_get_v): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) sgroup = server_group_template(policy='anti-affinity', rules={'max_server_per_host': 3}) result = self.assertRaises( webob.exc.HTTPConflict, self.controller.create, req, body={'server_group': sgroup}) self.assertIn("Creating an anti-affinity group with rule " "max_server_per_host > 1 is not yet supported.", six.text_type(result)) def test_create_server_group(self): policies = ['affinity', 'anti-affinity'] for policy in policies: self._create_server_group_normal(policy=policy) def test_policies_since_264(self): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) # 'policies' isn't allowed in request >= 2.64 sgroup = server_group_template(policies=['anti-affinity']) self.assertRaises( self.validation_error, self.controller.create, req, body={'server_group': sgroup}) def test_create_server_group_without_policy(self): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) # 'policy' is required request key in request >= 2.64 sgroup = server_group_template() self.assertRaises(self.validation_error, self.controller.create, req, body={'server_group': sgroup}) def test_create_server_group_with_illegal_policies(self): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) # blank policy sgroup = server_group_template(policy='') self.assertRaises(self.validation_error, self.controller.create, req, body={'server_group': sgroup}) # policy as integer sgroup = server_group_template(policy=7) self.assertRaises(self.validation_error, self.controller.create, req, body={'server_group': sgroup}) # policy as string sgroup = server_group_template(policy='invalid') self.assertRaises(self.validation_error, self.controller.create, req, body={'server_group': sgroup}) # policy as None sgroup = server_group_template(policy=None) self.assertRaises(self.validation_error, self.controller.create, req, body={'server_group': sgroup}) def test_additional_params(self): req = fakes.HTTPRequest.blank('', version=self.wsgi_api_version) sgroup = server_group_template(unknown='unknown') self.assertRaises(self.validation_error, self.controller.create, req, body={'server_group': sgroup})
mikalstill/nova
nova/tests/unit/api/openstack/compute/test_server_groups.py
Python
apache-2.0
36,927
0.002194
"""User-friendly public interface to polynomial functions. """ from __future__ import print_function, division from sympy.core import ( S, Basic, Expr, I, Integer, Add, Mul, Dummy, Tuple ) from sympy.core.mul import _keep_coeff from sympy.core.symbol import Symbol from sympy.core.basic import preorder_traversal from sympy.core.relational import Relational from sympy.core.sympify import sympify from sympy.core.decorators import _sympifyit from sympy.logic.boolalg import BooleanAtom from sympy.polys.polyclasses import DMP from sympy.polys.polyutils import ( basic_from_dict, _sort_gens, _unify_gens, _dict_reorder, _dict_from_expr, _parallel_dict_from_expr, ) from sympy.polys.rationaltools import together from sympy.polys.rootisolation import dup_isolate_real_roots_list from sympy.polys.groebnertools import groebner as _groebner from sympy.polys.fglmtools import matrix_fglm from sympy.polys.monomials import Monomial from sympy.polys.orderings import monomial_key from sympy.polys.polyerrors import ( OperationNotSupported, DomainError, CoercionFailed, UnificationFailed, GeneratorsNeeded, PolynomialError, MultivariatePolynomialError, ExactQuotientFailed, PolificationFailed, ComputationFailed, GeneratorsError, ) from sympy.utilities import group, sift, public import sympy.polys import sympy.mpmath from sympy.mpmath.libmp.libhyper import NoConvergence from sympy.polys.domains import FF, QQ, ZZ from sympy.polys.constructor import construct_domain from sympy.polys import polyoptions as options from sympy.core.compatibility import iterable @public class Poly(Expr): """Generic class for representing polynomial expressions. """ __slots__ = ['rep', 'gens'] is_commutative = True is_Poly = True def __new__(cls, rep, *gens, **args): """Create a new polynomial instance out of something useful. """ opt = options.build_options(gens, args) if 'order' in opt: raise NotImplementedError("'order' keyword is not implemented yet") if iterable(rep, exclude=str): if isinstance(rep, dict): return cls._from_dict(rep, opt) else: return cls._from_list(list(rep), opt) else: rep = sympify(rep) if rep.is_Poly: return cls._from_poly(rep, opt) else: return cls._from_expr(rep, opt) @classmethod def new(cls, rep, *gens): """Construct :class:`Poly` instance from raw representation. """ if not isinstance(rep, DMP): raise PolynomialError( "invalid polynomial representation: %s" % rep) elif rep.lev != len(gens) - 1: raise PolynomialError("invalid arguments: %s, %s" % (rep, gens)) obj = Basic.__new__(cls) obj.rep = rep obj.gens = gens return obj @classmethod def from_dict(cls, rep, *gens, **args): """Construct a polynomial from a ``dict``. """ opt = options.build_options(gens, args) return cls._from_dict(rep, opt) @classmethod def from_list(cls, rep, *gens, **args): """Construct a polynomial from a ``list``. """ opt = options.build_options(gens, args) return cls._from_list(rep, opt) @classmethod def from_poly(cls, rep, *gens, **args): """Construct a polynomial from a polynomial. """ opt = options.build_options(gens, args) return cls._from_poly(rep, opt) @classmethod def from_expr(cls, rep, *gens, **args): """Construct a polynomial from an expression. """ opt = options.build_options(gens, args) return cls._from_expr(rep, opt) @classmethod def _from_dict(cls, rep, opt): """Construct a polynomial from a ``dict``. """ gens = opt.gens if not gens: raise GeneratorsNeeded( "can't initialize from 'dict' without generators") level = len(gens) - 1 domain = opt.domain if domain is None: domain, rep = construct_domain(rep, opt=opt) else: for monom, coeff in rep.items(): rep[monom] = domain.convert(coeff) return cls.new(DMP.from_dict(rep, level, domain), *gens) @classmethod def _from_list(cls, rep, opt): """Construct a polynomial from a ``list``. """ gens = opt.gens if not gens: raise GeneratorsNeeded( "can't initialize from 'list' without generators") elif len(gens) != 1: raise MultivariatePolynomialError( "'list' representation not supported") level = len(gens) - 1 domain = opt.domain if domain is None: domain, rep = construct_domain(rep, opt=opt) else: rep = list(map(domain.convert, rep)) return cls.new(DMP.from_list(rep, level, domain), *gens) @classmethod def _from_poly(cls, rep, opt): """Construct a polynomial from a polynomial. """ if cls != rep.__class__: rep = cls.new(rep.rep, *rep.gens) gens = opt.gens field = opt.field domain = opt.domain if gens and rep.gens != gens: if set(rep.gens) != set(gens): return cls._from_expr(rep.as_expr(), opt) else: rep = rep.reorder(*gens) if 'domain' in opt and domain: rep = rep.set_domain(domain) elif field is True: rep = rep.to_field() return rep @classmethod def _from_expr(cls, rep, opt): """Construct a polynomial from an expression. """ rep, opt = _dict_from_expr(rep, opt) return cls._from_dict(rep, opt) def _hashable_content(self): """Allow SymPy to hash Poly instances. """ return (self.rep, self.gens) def __hash__(self): return super(Poly, self).__hash__() @property def free_symbols(self): """ Free symbols of a polynomial expression. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1).free_symbols set([x]) >>> Poly(x**2 + y).free_symbols set([x, y]) >>> Poly(x**2 + y, x).free_symbols set([x, y]) """ symbols = set([]) for gen in self.gens: symbols |= gen.free_symbols return symbols | self.free_symbols_in_domain @property def free_symbols_in_domain(self): """ Free symbols of the domain of ``self``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1).free_symbols_in_domain set() >>> Poly(x**2 + y).free_symbols_in_domain set() >>> Poly(x**2 + y, x).free_symbols_in_domain set([y]) """ domain, symbols = self.rep.dom, set() if domain.is_Composite: for gen in domain.symbols: symbols |= gen.free_symbols elif domain.is_EX: for coeff in self.coeffs(): symbols |= coeff.free_symbols return symbols @property def args(self): """ Don't mess up with the core. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).args (x**2 + 1,) """ return (self.as_expr(),) @property def gen(self): """ Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x """ return self.gens[0] @property def domain(self): """Get the ground domain of ``self``. """ return self.get_domain() @property def zero(self): """Return zero polynomial with ``self``'s properties. """ return self.new(self.rep.zero(self.rep.lev, self.rep.dom), *self.gens) @property def one(self): """Return one polynomial with ``self``'s properties. """ return self.new(self.rep.one(self.rep.lev, self.rep.dom), *self.gens) @property def unit(self): """Return unit polynomial with ``self``'s properties. """ return self.new(self.rep.unit(self.rep.lev, self.rep.dom), *self.gens) def unify(f, g): """ Make ``f`` and ``g`` belong to the same domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f, g = Poly(x/2 + 1), Poly(2*x + 1) >>> f Poly(1/2*x + 1, x, domain='QQ') >>> g Poly(2*x + 1, x, domain='ZZ') >>> F, G = f.unify(g) >>> F Poly(1/2*x + 1, x, domain='QQ') >>> G Poly(2*x + 1, x, domain='QQ') """ _, per, F, G = f._unify(g) return per(F), per(G) def _unify(f, g): g = sympify(g) if not g.is_Poly: try: return f.rep.dom, f.per, f.rep, f.rep.per(f.rep.dom.from_sympy(g)) except CoercionFailed: raise UnificationFailed("can't unify %s with %s" % (f, g)) if isinstance(f.rep, DMP) and isinstance(g.rep, DMP): gens = _unify_gens(f.gens, g.gens) dom, lev = f.rep.dom.unify(g.rep.dom, gens), len(gens) - 1 if f.gens != gens: f_monoms, f_coeffs = _dict_reorder( f.rep.to_dict(), f.gens, gens) if f.rep.dom != dom: f_coeffs = [dom.convert(c, f.rep.dom) for c in f_coeffs] F = DMP(dict(list(zip(f_monoms, f_coeffs))), dom, lev) else: F = f.rep.convert(dom) if g.gens != gens: g_monoms, g_coeffs = _dict_reorder( g.rep.to_dict(), g.gens, gens) if g.rep.dom != dom: g_coeffs = [dom.convert(c, g.rep.dom) for c in g_coeffs] G = DMP(dict(list(zip(g_monoms, g_coeffs))), dom, lev) else: G = g.rep.convert(dom) else: raise UnificationFailed("can't unify %s with %s" % (f, g)) cls = f.__class__ def per(rep, dom=dom, gens=gens, remove=None): if remove is not None: gens = gens[:remove] + gens[remove + 1:] if not gens: return dom.to_sympy(rep) return cls.new(rep, *gens) return dom, per, F, G def per(f, rep, gens=None, remove=None): """ Create a Poly out of the given representation. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x, y >>> from sympy.polys.polyclasses import DMP >>> a = Poly(x**2 + 1) >>> a.per(DMP([ZZ(1), ZZ(1)], ZZ), gens=[y]) Poly(y + 1, y, domain='ZZ') """ if gens is None: gens = f.gens if remove is not None: gens = gens[:remove] + gens[remove + 1:] if not gens: return f.rep.dom.to_sympy(rep) return f.__class__.new(rep, *gens) def set_domain(f, domain): """Set the ground domain of ``f``. """ opt = options.build_options(f.gens, {'domain': domain}) return f.per(f.rep.convert(opt.domain)) def get_domain(f): """Get the ground domain of ``f``. """ return f.rep.dom def set_modulus(f, modulus): """ Set the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(5*x**2 + 2*x - 1, x).set_modulus(2) Poly(x**2 + 1, x, modulus=2) """ modulus = options.Modulus.preprocess(modulus) return f.set_domain(FF(modulus)) def get_modulus(f): """ Get the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, modulus=2).get_modulus() 2 """ domain = f.get_domain() if domain.is_FiniteField: return Integer(domain.characteristic()) else: raise PolynomialError("not a polynomial over a Galois field") def _eval_subs(f, old, new): """Internal implementation of :func:`subs`. """ if old in f.gens: if new.is_number: return f.eval(old, new) else: try: return f.replace(old, new) except PolynomialError: pass return f.as_expr().subs(old, new) def exclude(f): """ Remove unnecessary generators from ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import a, b, c, d, x >>> Poly(a + x, a, b, c, d, x).exclude() Poly(a + x, a, x, domain='ZZ') """ J, new = f.rep.exclude() gens = [] for j in range(len(f.gens)): if j not in J: gens.append(f.gens[j]) return f.per(new, gens=gens) def replace(f, x, y=None): """ Replace ``x`` with ``y`` in generators list. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1, x).replace(x, y) Poly(y**2 + 1, y, domain='ZZ') """ if y is None: if f.is_univariate: x, y = f.gen, x else: raise PolynomialError( "syntax supported only in univariate case") if x == y: return f if x in f.gens and y not in f.gens: dom = f.get_domain() if not dom.is_Composite or y not in dom.symbols: gens = list(f.gens) gens[gens.index(x)] = y return f.per(f.rep, gens=gens) raise PolynomialError("can't replace %s with %s in %s" % (x, y, f)) def reorder(f, *gens, **args): """ Efficiently apply new order of generators. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x*y**2, x, y).reorder(y, x) Poly(y**2*x + x**2, y, x, domain='ZZ') """ opt = options.Options((), args) if not gens: gens = _sort_gens(f.gens, opt=opt) elif set(f.gens) != set(gens): raise PolynomialError( "generators list can differ only up to order of elements") rep = dict(list(zip(*_dict_reorder(f.rep.to_dict(), f.gens, gens)))) return f.per(DMP(rep, f.rep.dom, len(gens) - 1), gens=gens) def ltrim(f, gen): """ Remove dummy generators from the "left" of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(y**2 + y*z**2, x, y, z).ltrim(y) Poly(y**2 + y*z**2, y, z, domain='ZZ') """ rep = f.as_dict(native=True) j = f._gen_to_level(gen) terms = {} for monom, coeff in rep.items(): monom = monom[j:] if monom not in terms: terms[monom] = coeff else: raise PolynomialError("can't left trim %s" % f) gens = f.gens[j:] return f.new(DMP.from_dict(terms, len(gens) - 1, f.rep.dom), *gens) def has_only_gens(f, *gens): """ Return ``True`` if ``Poly(f, *gens)`` retains ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x*y + 1, x, y, z).has_only_gens(x, y) True >>> Poly(x*y + z, x, y, z).has_only_gens(x, y) False """ indices = set([]) for gen in gens: try: index = f.gens.index(gen) except ValueError: raise GeneratorsError( "%s doesn't have %s as generator" % (f, gen)) else: indices.add(index) for monom in f.monoms(): for i, elt in enumerate(monom): if i not in indices and elt: return False return True def to_ring(f): """ Make the ground domain a ring. Examples ======== >>> from sympy import Poly, QQ >>> from sympy.abc import x >>> Poly(x**2 + 1, domain=QQ).to_ring() Poly(x**2 + 1, x, domain='ZZ') """ if hasattr(f.rep, 'to_ring'): result = f.rep.to_ring() else: # pragma: no cover raise OperationNotSupported(f, 'to_ring') return f.per(result) def to_field(f): """ Make the ground domain a field. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(x**2 + 1, x, domain=ZZ).to_field() Poly(x**2 + 1, x, domain='QQ') """ if hasattr(f.rep, 'to_field'): result = f.rep.to_field() else: # pragma: no cover raise OperationNotSupported(f, 'to_field') return f.per(result) def to_exact(f): """ Make the ground domain exact. Examples ======== >>> from sympy import Poly, RR >>> from sympy.abc import x >>> Poly(x**2 + 1.0, x, domain=RR).to_exact() Poly(x**2 + 1, x, domain='QQ') """ if hasattr(f.rep, 'to_exact'): result = f.rep.to_exact() else: # pragma: no cover raise OperationNotSupported(f, 'to_exact') return f.per(result) def retract(f, field=None): """ Recalculate the ground domain of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x, domain='QQ[y]') >>> f Poly(x**2 + 1, x, domain='QQ[y]') >>> f.retract() Poly(x**2 + 1, x, domain='ZZ') >>> f.retract(field=True) Poly(x**2 + 1, x, domain='QQ') """ dom, rep = construct_domain(f.as_dict(zero=True), field=field, composite=f.domain.is_Composite or None) return f.from_dict(rep, f.gens, domain=dom) def slice(f, x, m, n=None): """Take a continuous subsequence of terms of ``f``. """ if n is None: j, m, n = 0, x, m else: j = f._gen_to_level(x) m, n = int(m), int(n) if hasattr(f.rep, 'slice'): result = f.rep.slice(m, n, j) else: # pragma: no cover raise OperationNotSupported(f, 'slice') return f.per(result) def coeffs(f, order=None): """ Returns all non-zero coefficients from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x + 3, x).coeffs() [1, 2, 3] See Also ======== all_coeffs coeff_monomial nth """ return [f.rep.dom.to_sympy(c) for c in f.rep.coeffs(order=order)] def monoms(f, order=None): """ Returns all non-zero monomials from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).monoms() [(2, 0), (1, 2), (1, 1), (0, 1)] See Also ======== all_monoms """ return f.rep.monoms(order=order) def terms(f, order=None): """ Returns all non-zero terms from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).terms() [((2, 0), 1), ((1, 2), 2), ((1, 1), 1), ((0, 1), 3)] See Also ======== all_terms """ return [(m, f.rep.dom.to_sympy(c)) for m, c in f.rep.terms(order=order)] def all_coeffs(f): """ Returns all coefficients from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_coeffs() [1, 0, 2, -1] """ return [f.rep.dom.to_sympy(c) for c in f.rep.all_coeffs()] def all_monoms(f): """ Returns all monomials from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_monoms() [(3,), (2,), (1,), (0,)] See Also ======== all_terms """ return f.rep.all_monoms() def all_terms(f): """ Returns all terms from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_terms() [((3,), 1), ((2,), 0), ((1,), 2), ((0,), -1)] """ return [(m, f.rep.dom.to_sympy(c)) for m, c in f.rep.all_terms()] def termwise(f, func, *gens, **args): """ Apply a function to all terms of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> def func(k, coeff): ... k = k[0] ... return coeff//10**(2-k) >>> Poly(x**2 + 20*x + 400).termwise(func) Poly(x**2 + 2*x + 4, x, domain='ZZ') """ terms = {} for monom, coeff in f.terms(): result = func(monom, coeff) if isinstance(result, tuple): monom, coeff = result else: coeff = result if coeff: if monom not in terms: terms[monom] = coeff else: raise PolynomialError( "%s monomial was generated twice" % monom) return f.from_dict(terms, *(gens or f.gens), **args) def length(f): """ Returns the number of non-zero terms in ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x - 1).length() 3 """ return len(f.as_dict()) def as_dict(f, native=False, zero=False): """ Switch to a ``dict`` representation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 - y, x, y).as_dict() {(0, 1): -1, (1, 2): 2, (2, 0): 1} """ if native: return f.rep.to_dict(zero=zero) else: return f.rep.to_sympy_dict(zero=zero) def as_list(f, native=False): """Switch to a ``list`` representation. """ if native: return f.rep.to_list() else: return f.rep.to_sympy_list() def as_expr(f, *gens): """ Convert a Poly instance to an Expr instance. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2 + 2*x*y**2 - y, x, y) >>> f.as_expr() x**2 + 2*x*y**2 - y >>> f.as_expr({x: 5}) 10*y**2 - y + 25 >>> f.as_expr(5, 6) 379 """ if not gens: gens = f.gens elif len(gens) == 1 and isinstance(gens[0], dict): mapping = gens[0] gens = list(f.gens) for gen, value in mapping.items(): try: index = gens.index(gen) except ValueError: raise GeneratorsError( "%s doesn't have %s as generator" % (f, gen)) else: gens[index] = value return basic_from_dict(f.rep.to_sympy_dict(), *gens) def lift(f): """ Convert algebraic coefficients to rationals. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**2 + I*x + 1, x, extension=I).lift() Poly(x**4 + 3*x**2 + 1, x, domain='QQ') """ if hasattr(f.rep, 'lift'): result = f.rep.lift() else: # pragma: no cover raise OperationNotSupported(f, 'lift') return f.per(result) def deflate(f): """ Reduce degree of ``f`` by mapping ``x_i**m`` to ``y_i``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3 + 1, x, y).deflate() ((3, 2), Poly(x**2*y + x + 1, x, y, domain='ZZ')) """ if hasattr(f.rep, 'deflate'): J, result = f.rep.deflate() else: # pragma: no cover raise OperationNotSupported(f, 'deflate') return J, f.per(result) def inject(f, front=False): """ Inject ground domain generators into ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x) >>> f.inject() Poly(x**2*y + x*y**3 + x*y + 1, x, y, domain='ZZ') >>> f.inject(front=True) Poly(y**3*x + y*x**2 + y*x + 1, y, x, domain='ZZ') """ dom = f.rep.dom if dom.is_Numerical: return f elif not dom.is_Poly: raise DomainError("can't inject generators over %s" % dom) if hasattr(f.rep, 'inject'): result = f.rep.inject(front=front) else: # pragma: no cover raise OperationNotSupported(f, 'inject') if front: gens = dom.symbols + f.gens else: gens = f.gens + dom.symbols return f.new(result, *gens) def eject(f, *gens): """ Eject selected generators into the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x, y) >>> f.eject(x) Poly(x*y**3 + (x**2 + x)*y + 1, y, domain='ZZ[x]') >>> f.eject(y) Poly(y*x**2 + (y**3 + y)*x + 1, x, domain='ZZ[y]') """ dom = f.rep.dom if not dom.is_Numerical: raise DomainError("can't eject generators over %s" % dom) n, k = len(f.gens), len(gens) if f.gens[:k] == gens: _gens, front = f.gens[k:], True elif f.gens[-k:] == gens: _gens, front = f.gens[:-k], False else: raise NotImplementedError( "can only eject front or back generators") dom = dom.inject(*gens) if hasattr(f.rep, 'eject'): result = f.rep.eject(dom, front=front) else: # pragma: no cover raise OperationNotSupported(f, 'eject') return f.new(result, *_gens) def terms_gcd(f): """ Remove GCD of terms from the polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3*y, x, y).terms_gcd() ((3, 1), Poly(x**3*y + 1, x, y, domain='ZZ')) """ if hasattr(f.rep, 'terms_gcd'): J, result = f.rep.terms_gcd() else: # pragma: no cover raise OperationNotSupported(f, 'terms_gcd') return J, f.per(result) def add_ground(f, coeff): """ Add an element of the ground domain to ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).add_ground(2) Poly(x + 3, x, domain='ZZ') """ if hasattr(f.rep, 'add_ground'): result = f.rep.add_ground(coeff) else: # pragma: no cover raise OperationNotSupported(f, 'add_ground') return f.per(result) def sub_ground(f, coeff): """ Subtract an element of the ground domain from ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).sub_ground(2) Poly(x - 1, x, domain='ZZ') """ if hasattr(f.rep, 'sub_ground'): result = f.rep.sub_ground(coeff) else: # pragma: no cover raise OperationNotSupported(f, 'sub_ground') return f.per(result) def mul_ground(f, coeff): """ Multiply ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).mul_ground(2) Poly(2*x + 2, x, domain='ZZ') """ if hasattr(f.rep, 'mul_ground'): result = f.rep.mul_ground(coeff) else: # pragma: no cover raise OperationNotSupported(f, 'mul_ground') return f.per(result) def quo_ground(f, coeff): """ Quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).quo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).quo_ground(2) Poly(x + 1, x, domain='ZZ') """ if hasattr(f.rep, 'quo_ground'): result = f.rep.quo_ground(coeff) else: # pragma: no cover raise OperationNotSupported(f, 'quo_ground') return f.per(result) def exquo_ground(f, coeff): """ Exact quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).exquo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).exquo_ground(2) Traceback (most recent call last): ... ExactQuotientFailed: 2 does not divide 3 in ZZ """ if hasattr(f.rep, 'exquo_ground'): result = f.rep.exquo_ground(coeff) else: # pragma: no cover raise OperationNotSupported(f, 'exquo_ground') return f.per(result) def abs(f): """ Make all coefficients in ``f`` positive. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).abs() Poly(x**2 + 1, x, domain='ZZ') """ if hasattr(f.rep, 'abs'): result = f.rep.abs() else: # pragma: no cover raise OperationNotSupported(f, 'abs') return f.per(result) def neg(f): """ Negate all coefficients in ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).neg() Poly(-x**2 + 1, x, domain='ZZ') >>> -Poly(x**2 - 1, x) Poly(-x**2 + 1, x, domain='ZZ') """ if hasattr(f.rep, 'neg'): result = f.rep.neg() else: # pragma: no cover raise OperationNotSupported(f, 'neg') return f.per(result) def add(f, g): """ Add two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).add(Poly(x - 2, x)) Poly(x**2 + x - 1, x, domain='ZZ') >>> Poly(x**2 + 1, x) + Poly(x - 2, x) Poly(x**2 + x - 1, x, domain='ZZ') """ g = sympify(g) if not g.is_Poly: return f.add_ground(g) _, per, F, G = f._unify(g) if hasattr(f.rep, 'add'): result = F.add(G) else: # pragma: no cover raise OperationNotSupported(f, 'add') return per(result) def sub(f, g): """ Subtract two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).sub(Poly(x - 2, x)) Poly(x**2 - x + 3, x, domain='ZZ') >>> Poly(x**2 + 1, x) - Poly(x - 2, x) Poly(x**2 - x + 3, x, domain='ZZ') """ g = sympify(g) if not g.is_Poly: return f.sub_ground(g) _, per, F, G = f._unify(g) if hasattr(f.rep, 'sub'): result = F.sub(G) else: # pragma: no cover raise OperationNotSupported(f, 'sub') return per(result) def mul(f, g): """ Multiply two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).mul(Poly(x - 2, x)) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') >>> Poly(x**2 + 1, x)*Poly(x - 2, x) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') """ g = sympify(g) if not g.is_Poly: return f.mul_ground(g) _, per, F, G = f._unify(g) if hasattr(f.rep, 'mul'): result = F.mul(G) else: # pragma: no cover raise OperationNotSupported(f, 'mul') return per(result) def sqr(f): """ Square a polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).sqr() Poly(x**2 - 4*x + 4, x, domain='ZZ') >>> Poly(x - 2, x)**2 Poly(x**2 - 4*x + 4, x, domain='ZZ') """ if hasattr(f.rep, 'sqr'): result = f.rep.sqr() else: # pragma: no cover raise OperationNotSupported(f, 'sqr') return f.per(result) def pow(f, n): """ Raise ``f`` to a non-negative power ``n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).pow(3) Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') >>> Poly(x - 2, x)**3 Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') """ n = int(n) if hasattr(f.rep, 'pow'): result = f.rep.pow(n) else: # pragma: no cover raise OperationNotSupported(f, 'pow') return f.per(result) def pdiv(f, g): """ Polynomial pseudo-division of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pdiv(Poly(2*x - 4, x)) (Poly(2*x + 4, x, domain='ZZ'), Poly(20, x, domain='ZZ')) """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'pdiv'): q, r = F.pdiv(G) else: # pragma: no cover raise OperationNotSupported(f, 'pdiv') return per(q), per(r) def prem(f, g): """ Polynomial pseudo-remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).prem(Poly(2*x - 4, x)) Poly(20, x, domain='ZZ') """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'prem'): result = F.prem(G) else: # pragma: no cover raise OperationNotSupported(f, 'prem') return per(result) def pquo(f, g): """ Polynomial pseudo-quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pquo(Poly(2*x - 4, x)) Poly(2*x + 4, x, domain='ZZ') >>> Poly(x**2 - 1, x).pquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'pquo'): result = F.pquo(G) else: # pragma: no cover raise OperationNotSupported(f, 'pquo') return per(result) def pexquo(f, g): """ Polynomial exact pseudo-quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).pexquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') >>> Poly(x**2 + 1, x).pexquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'pexquo'): try: result = F.pexquo(G) except ExactQuotientFailed as exc: raise exc.new(f.as_expr(), g.as_expr()) else: # pragma: no cover raise OperationNotSupported(f, 'pexquo') return per(result) def div(f, g, auto=True): """ Polynomial division with remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x)) (Poly(1/2*x + 1, x, domain='QQ'), Poly(5, x, domain='QQ')) >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x), auto=False) (Poly(0, x, domain='ZZ'), Poly(x**2 + 1, x, domain='ZZ')) """ dom, per, F, G = f._unify(g) retract = False if auto and dom.has_Ring and not dom.has_Field: F, G = F.to_field(), G.to_field() retract = True if hasattr(f.rep, 'div'): q, r = F.div(G) else: # pragma: no cover raise OperationNotSupported(f, 'div') if retract: try: Q, R = q.to_ring(), r.to_ring() except CoercionFailed: pass else: q, r = Q, R return per(q), per(r) def rem(f, g, auto=True): """ Computes the polynomial remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x)) Poly(5, x, domain='ZZ') >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x), auto=False) Poly(x**2 + 1, x, domain='ZZ') """ dom, per, F, G = f._unify(g) retract = False if auto and dom.has_Ring and not dom.has_Field: F, G = F.to_field(), G.to_field() retract = True if hasattr(f.rep, 'rem'): r = F.rem(G) else: # pragma: no cover raise OperationNotSupported(f, 'rem') if retract: try: r = r.to_ring() except CoercionFailed: pass return per(r) def quo(f, g, auto=True): """ Computes polynomial quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).quo(Poly(2*x - 4, x)) Poly(1/2*x + 1, x, domain='QQ') >>> Poly(x**2 - 1, x).quo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') """ dom, per, F, G = f._unify(g) retract = False if auto and dom.has_Ring and not dom.has_Field: F, G = F.to_field(), G.to_field() retract = True if hasattr(f.rep, 'quo'): q = F.quo(G) else: # pragma: no cover raise OperationNotSupported(f, 'quo') if retract: try: q = q.to_ring() except CoercionFailed: pass return per(q) def exquo(f, g, auto=True): """ Computes polynomial exact quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).exquo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') >>> Poly(x**2 + 1, x).exquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 """ dom, per, F, G = f._unify(g) retract = False if auto and dom.has_Ring and not dom.has_Field: F, G = F.to_field(), G.to_field() retract = True if hasattr(f.rep, 'exquo'): try: q = F.exquo(G) except ExactQuotientFailed as exc: raise exc.new(f.as_expr(), g.as_expr()) else: # pragma: no cover raise OperationNotSupported(f, 'exquo') if retract: try: q = q.to_ring() except CoercionFailed: pass return per(q) def _gen_to_level(f, gen): """Returns level associated with the given generator. """ if isinstance(gen, int): length = len(f.gens) if -length <= gen < length: if gen < 0: return length + gen else: return gen else: raise PolynomialError("-%s <= gen < %s expected, got %s" % (length, length, gen)) else: try: return f.gens.index(sympify(gen)) except ValueError: raise PolynomialError( "a valid generator expected, got %s" % gen) def degree(f, gen=0): """ Returns degree of ``f`` in ``x_j``. The degree of 0 is negative infinity. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree() 2 >>> Poly(x**2 + y*x + y, x, y).degree(y) 1 >>> Poly(0, x).degree() -oo """ j = f._gen_to_level(gen) if hasattr(f.rep, 'degree'): return f.rep.degree(j) else: # pragma: no cover raise OperationNotSupported(f, 'degree') def degree_list(f): """ Returns a list of degrees of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree_list() (2, 1) """ if hasattr(f.rep, 'degree_list'): return f.rep.degree_list() else: # pragma: no cover raise OperationNotSupported(f, 'degree_list') def total_degree(f): """ Returns the total degree of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).total_degree() 2 >>> Poly(x + y**5, x, y).total_degree() 5 """ if hasattr(f.rep, 'total_degree'): return f.rep.total_degree() else: # pragma: no cover raise OperationNotSupported(f, 'total_degree') def homogenize(f, s): """ Returns the homogeneous polynomial of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(x**5 + 2*x**2*y**2 + 9*x*y**3) >>> f.homogenize(z) Poly(x**5 + 2*x**2*y**2*z + 9*x*y**3*z, x, y, z, domain='ZZ') """ if not isinstance(s, Symbol): raise TypeError("``Symbol`` expected, got %s" % type(s)) if s in f.gens: i = f.gens.index(s) gens = f.gens else: i = len(f.gens) gens = f.gens + (s,) if hasattr(f.rep, 'homogenize'): return f.per(f.rep.homogenize(i), gens=gens) raise OperationNotSupported(f, 'homogeneous_order') def homogeneous_order(f): """ Returns the homogeneous order of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. This degree is the homogeneous order of ``f``. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**5 + 2*x**3*y**2 + 9*x*y**4) >>> f.homogeneous_order() 5 """ if hasattr(f.rep, 'homogeneous_order'): return f.rep.homogeneous_order() else: # pragma: no cover raise OperationNotSupported(f, 'homogeneous_order') def LC(f, order=None): """ Returns the leading coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(4*x**3 + 2*x**2 + 3*x, x).LC() 4 """ if order is not None: return f.coeffs(order)[0] if hasattr(f.rep, 'LC'): result = f.rep.LC() else: # pragma: no cover raise OperationNotSupported(f, 'LC') return f.rep.dom.to_sympy(result) def TC(f): """ Returns the trailing coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).TC() 0 """ if hasattr(f.rep, 'TC'): result = f.rep.TC() else: # pragma: no cover raise OperationNotSupported(f, 'TC') return f.rep.dom.to_sympy(result) def EC(f, order=None): """ Returns the last non-zero coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).EC() 3 """ if hasattr(f.rep, 'coeffs'): return f.coeffs(order)[-1] else: # pragma: no cover raise OperationNotSupported(f, 'EC') def coeff_monomial(f, monom): """ Returns the coefficient of ``monom`` in ``f`` if there, else None. Examples ======== >>> from sympy import Poly, exp >>> from sympy.abc import x, y >>> p = Poly(24*x*y*exp(8) + 23*x, x, y) >>> p.coeff_monomial(x) 23 >>> p.coeff_monomial(y) 0 >>> p.coeff_monomial(x*y) 24*exp(8) Note that ``Expr.coeff()`` behaves differently, collecting terms if possible; the Poly must be converted to an Expr to use that method, however: >>> p.as_expr().coeff(x) 24*y*exp(8) + 23 >>> p.as_expr().coeff(y) 24*x*exp(8) >>> p.as_expr().coeff(x*y) 24*exp(8) See Also ======== nth: more efficient query using exponents of the monomial's generators """ return f.nth(*Monomial(monom, f.gens).exponents) def nth(f, *N): """ Returns the ``n``-th coefficient of ``f`` where ``N`` are the exponents of the generators in the term of interest. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x, y >>> Poly(x**3 + 2*x**2 + 3*x, x).nth(2) 2 >>> Poly(x**3 + 2*x*y**2 + y**2, x, y).nth(1, 2) 2 >>> Poly(4*sqrt(x)*y) Poly(4*y*sqrt(x), y, sqrt(x), domain='ZZ') >>> _.nth(1, 1) 4 See Also ======== coeff_monomial """ if hasattr(f.rep, 'nth'): result = f.rep.nth(*list(map(int, N))) else: # pragma: no cover raise OperationNotSupported(f, 'nth') return f.rep.dom.to_sympy(result) def coeff(f, x, n=1, right=False): # the semantics of coeff_monomial and Expr.coeff are different; # if someone is working with a Poly, they should be aware of the # differences and chose the method best suited for the query. # Alternatively, a pure-polys method could be written here but # at this time the ``right`` keyword would be ignored because Poly # doesn't work with non-commutatives. raise NotImplementedError( 'Either convert to Expr with `as_expr` method ' 'to use Expr\'s coeff method or else use the ' '`coeff_monomial` method of Polys.') def LM(f, order=None): """ Returns the leading monomial of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LM() x**2*y**0 """ return Monomial(f.monoms(order)[0], f.gens) def EM(f, order=None): """ Returns the last non-zero monomial of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).EM() x**0*y**1 """ return Monomial(f.monoms(order)[-1], f.gens) def LT(f, order=None): """ Returns the leading term of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LT() (x**2*y**0, 4) """ monom, coeff = f.terms(order)[0] return Monomial(monom, f.gens), coeff def ET(f, order=None): """ Returns the last non-zero term of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).ET() (x**0*y**1, 3) """ monom, coeff = f.terms(order)[-1] return Monomial(monom, f.gens), coeff def max_norm(f): """ Returns maximum norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).max_norm() 3 """ if hasattr(f.rep, 'max_norm'): result = f.rep.max_norm() else: # pragma: no cover raise OperationNotSupported(f, 'max_norm') return f.rep.dom.to_sympy(result) def l1_norm(f): """ Returns l1 norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).l1_norm() 6 """ if hasattr(f.rep, 'l1_norm'): result = f.rep.l1_norm() else: # pragma: no cover raise OperationNotSupported(f, 'l1_norm') return f.rep.dom.to_sympy(result) def clear_denoms(f, convert=False): """ Clear denominators, but keep the ground domain. Examples ======== >>> from sympy import Poly, S, QQ >>> from sympy.abc import x >>> f = Poly(x/2 + S(1)/3, x, domain=QQ) >>> f.clear_denoms() (6, Poly(3*x + 2, x, domain='QQ')) >>> f.clear_denoms(convert=True) (6, Poly(3*x + 2, x, domain='ZZ')) """ if not f.rep.dom.has_Field: return S.One, f dom = f.get_domain() if dom.has_assoc_Ring: dom = f.rep.dom.get_ring() if hasattr(f.rep, 'clear_denoms'): coeff, result = f.rep.clear_denoms() else: # pragma: no cover raise OperationNotSupported(f, 'clear_denoms') coeff, f = dom.to_sympy(coeff), f.per(result) if not convert or not dom.has_assoc_Ring: return coeff, f else: return coeff, f.to_ring() def rat_clear_denoms(f, g): """ Clear denominators in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2/y + 1, x) >>> g = Poly(x**3 + y, x) >>> p, q = f.rat_clear_denoms(g) >>> p Poly(x**2 + y, x, domain='ZZ[y]') >>> q Poly(y*x**3 + y**2, x, domain='ZZ[y]') """ dom, per, f, g = f._unify(g) f = per(f) g = per(g) if not (dom.has_Field and dom.has_assoc_Ring): return f, g a, f = f.clear_denoms(convert=True) b, g = g.clear_denoms(convert=True) f = f.mul_ground(b) g = g.mul_ground(a) return f, g def integrate(f, *specs, **args): """ Computes indefinite integral of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x + 1, x).integrate() Poly(1/3*x**3 + x**2 + x, x, domain='QQ') >>> Poly(x*y**2 + x, x, y).integrate((0, 1), (1, 0)) Poly(1/2*x**2*y**2 + 1/2*x**2, x, y, domain='QQ') """ if args.get('auto', True) and f.rep.dom.has_Ring: f = f.to_field() if hasattr(f.rep, 'integrate'): if not specs: return f.per(f.rep.integrate(m=1)) rep = f.rep for spec in specs: if type(spec) is tuple: gen, m = spec else: gen, m = spec, 1 rep = rep.integrate(int(m), f._gen_to_level(gen)) return f.per(rep) else: # pragma: no cover raise OperationNotSupported(f, 'integrate') def diff(f, *specs): """ Computes partial derivative of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x + 1, x).diff() Poly(2*x + 2, x, domain='ZZ') >>> Poly(x*y**2 + x, x, y).diff((0, 0), (1, 1)) Poly(2*x*y, x, y, domain='ZZ') """ if hasattr(f.rep, 'diff'): if not specs: return f.per(f.rep.diff(m=1)) rep = f.rep for spec in specs: if type(spec) is tuple: gen, m = spec else: gen, m = spec, 1 rep = rep.diff(int(m), f._gen_to_level(gen)) return f.per(rep) else: # pragma: no cover raise OperationNotSupported(f, 'diff') def eval(f, x, a=None, auto=True): """ Evaluate ``f`` at ``a`` in the given variable. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x**2 + 2*x + 3, x).eval(2) 11 >>> Poly(2*x*y + 3*x + y + 2, x, y).eval(x, 2) Poly(5*y + 8, y, domain='ZZ') >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f.eval({x: 2}) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f.eval({x: 2, y: 5}) Poly(2*z + 31, z, domain='ZZ') >>> f.eval({x: 2, y: 5, z: 7}) 45 >>> f.eval((2, 5)) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') """ if a is None: if isinstance(x, dict): mapping = x for gen, value in mapping.items(): f = f.eval(gen, value) return f elif isinstance(x, (tuple, list)): values = x if len(values) > len(f.gens): raise ValueError("too many values provided") for gen, value in zip(f.gens, values): f = f.eval(gen, value) return f else: j, a = 0, x else: j = f._gen_to_level(x) if not hasattr(f.rep, 'eval'): # pragma: no cover raise OperationNotSupported(f, 'eval') try: result = f.rep.eval(a, j) except CoercionFailed: if not auto: raise DomainError("can't evaluate at %s in %s" % (a, f.rep.dom)) else: a_domain, [a] = construct_domain([a]) new_domain = f.get_domain().unify_with_symbols(a_domain, f.gens) f = f.set_domain(new_domain) a = new_domain.convert(a, a_domain) result = f.rep.eval(a, j) return f.per(result, remove=j) def __call__(f, *values): """ Evaluate ``f`` at the give values. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f(2) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5, 7) 45 """ return f.eval(values) def half_gcdex(f, g, auto=True): """ Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).half_gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) """ dom, per, F, G = f._unify(g) if auto and dom.has_Ring: F, G = F.to_field(), G.to_field() if hasattr(f.rep, 'half_gcdex'): s, h = F.half_gcdex(G) else: # pragma: no cover raise OperationNotSupported(f, 'half_gcdex') return per(s), per(h) def gcdex(f, g, auto=True): """ Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(1/5*x**2 - 6/5*x + 2, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) """ dom, per, F, G = f._unify(g) if auto and dom.has_Ring: F, G = F.to_field(), G.to_field() if hasattr(f.rep, 'gcdex'): s, t, h = F.gcdex(G) else: # pragma: no cover raise OperationNotSupported(f, 'gcdex') return per(s), per(t), per(h) def invert(f, g, auto=True): """ Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).invert(Poly(2*x - 1, x)) Poly(-4/3, x, domain='QQ') >>> Poly(x**2 - 1, x).invert(Poly(x - 1, x)) Traceback (most recent call last): ... NotInvertible: zero divisor """ dom, per, F, G = f._unify(g) if auto and dom.has_Ring: F, G = F.to_field(), G.to_field() if hasattr(f.rep, 'invert'): result = F.invert(G) else: # pragma: no cover raise OperationNotSupported(f, 'invert') return per(result) def revert(f, n): """Compute ``f**(-1)`` mod ``x**n``. """ if hasattr(f.rep, 'revert'): result = f.rep.revert(int(n)) else: # pragma: no cover raise OperationNotSupported(f, 'revert') return f.per(result) def subresultants(f, g): """ Computes the subresultant PRS of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).subresultants(Poly(x**2 - 1, x)) [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')] """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'subresultants'): result = F.subresultants(G) else: # pragma: no cover raise OperationNotSupported(f, 'subresultants') return list(map(per, result)) def resultant(f, g, includePRS=False): """ Computes the resultant of ``f`` and ``g`` via PRS. If includePRS=True, it includes the subresultant PRS in the result. Because the PRS is used to calculate the resultant, this is more efficient than calling :func:`subresultants` separately. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x) >>> f.resultant(Poly(x**2 - 1, x)) 4 >>> f.resultant(Poly(x**2 - 1, x), includePRS=True) (4, [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')]) """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'resultant'): if includePRS: result, R = F.resultant(G, includePRS=includePRS) else: result = F.resultant(G) else: # pragma: no cover raise OperationNotSupported(f, 'resultant') if includePRS: return (per(result, remove=0), list(map(per, R))) return per(result, remove=0) def discriminant(f): """ Computes the discriminant of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x + 3, x).discriminant() -8 """ if hasattr(f.rep, 'discriminant'): result = f.rep.discriminant() else: # pragma: no cover raise OperationNotSupported(f, 'discriminant') return f.per(result, remove=0) def dispersionset(f, g=None): r"""Compute the *dispersion set* of two polynomials. For two polynomials `f(x)` and `g(x)` with `\deg f > 0` and `\deg g > 0` the dispersion set `\operatorname{J}(f, g)` is defined as: .. math:: \operatorname{J}(f, g) & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\ & = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\} For a single polynomial one defines `\operatorname{J}(f) := \operatorname{J}(f, f)`. Examples ======== >>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x Dispersion set and dispersion of a simple polynomial: >>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6 Note that the definition of the dispersion is not symmetric: >>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo Computing the dispersion also works over field extensions: >>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4] We can even perform the computations for polynomials having symbolic coefficients: >>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1] See Also ======== dispersion References ========== 1. [ManWright94]_ 2. [Koepf98]_ 3. [Abramov71]_ 4. [Man93]_ """ from sympy.polys.dispersion import dispersionset return dispersionset(f, g) def dispersion(f, g=None): r"""Compute the *dispersion* of polynomials. For two polynomials `f(x)` and `g(x)` with `\deg f > 0` and `\deg g > 0` the dispersion `\operatorname{dis}(f, g)` is defined as: .. math:: \operatorname{dis}(f, g) & := \max\{ J(f,g) \cup \{0\} \} \\ & = \max\{ \{a \in \mathbb{N} | \gcd(f(x), g(x+a)) \neq 1\} \cup \{0\} \} and for a single polynomial `\operatorname{dis}(f) := \operatorname{dis}(f, f)`. Examples ======== >>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x Dispersion set and dispersion of a simple polynomial: >>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6 Note that the definition of the dispersion is not symmetric: >>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo Computing the dispersion also works over field extensions: >>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4] We can even perform the computations for polynomials having symbolic coefficients: >>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1] See Also ======== dispersionset References ========== 1. [ManWright94]_ 2. [Koepf98]_ 3. [Abramov71]_ 4. [Man93]_ """ from sympy.polys.dispersion import dispersion return dispersion(f, g) def cofactors(f, g): """ Returns the GCD of ``f`` and ``g`` and their cofactors. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).cofactors(Poly(x**2 - 3*x + 2, x)) (Poly(x - 1, x, domain='ZZ'), Poly(x + 1, x, domain='ZZ'), Poly(x - 2, x, domain='ZZ')) """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'cofactors'): h, cff, cfg = F.cofactors(G) else: # pragma: no cover raise OperationNotSupported(f, 'cofactors') return per(h), per(cff), per(cfg) def gcd(f, g): """ Returns the polynomial GCD of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).gcd(Poly(x**2 - 3*x + 2, x)) Poly(x - 1, x, domain='ZZ') """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'gcd'): result = F.gcd(G) else: # pragma: no cover raise OperationNotSupported(f, 'gcd') return per(result) def lcm(f, g): """ Returns polynomial LCM of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).lcm(Poly(x**2 - 3*x + 2, x)) Poly(x**3 - 2*x**2 - x + 2, x, domain='ZZ') """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'lcm'): result = F.lcm(G) else: # pragma: no cover raise OperationNotSupported(f, 'lcm') return per(result) def trunc(f, p): """ Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 + 3*x**2 + 5*x + 7, x).trunc(3) Poly(-x**3 - x + 1, x, domain='ZZ') """ p = f.rep.dom.convert(p) if hasattr(f.rep, 'trunc'): result = f.rep.trunc(p) else: # pragma: no cover raise OperationNotSupported(f, 'trunc') return f.per(result) def monic(f, auto=True): """ Divides all coefficients by ``LC(f)``. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(3*x**2 + 6*x + 9, x, domain=ZZ).monic() Poly(x**2 + 2*x + 3, x, domain='QQ') >>> Poly(3*x**2 + 4*x + 2, x, domain=ZZ).monic() Poly(x**2 + 4/3*x + 2/3, x, domain='QQ') """ if auto and f.rep.dom.has_Ring: f = f.to_field() if hasattr(f.rep, 'monic'): result = f.rep.monic() else: # pragma: no cover raise OperationNotSupported(f, 'monic') return f.per(result) def content(f): """ Returns the GCD of polynomial coefficients. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(6*x**2 + 8*x + 12, x).content() 2 """ if hasattr(f.rep, 'content'): result = f.rep.content() else: # pragma: no cover raise OperationNotSupported(f, 'content') return f.rep.dom.to_sympy(result) def primitive(f): """ Returns the content and a primitive form of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 8*x + 12, x).primitive() (2, Poly(x**2 + 4*x + 6, x, domain='ZZ')) """ if hasattr(f.rep, 'primitive'): cont, result = f.rep.primitive() else: # pragma: no cover raise OperationNotSupported(f, 'primitive') return f.rep.dom.to_sympy(cont), f.per(result) def compose(f, g): """ Computes the functional composition of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x, x).compose(Poly(x - 1, x)) Poly(x**2 - x, x, domain='ZZ') """ _, per, F, G = f._unify(g) if hasattr(f.rep, 'compose'): result = F.compose(G) else: # pragma: no cover raise OperationNotSupported(f, 'compose') return per(result) def decompose(f): """ Computes a functional decomposition of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**4 + 2*x**3 - x - 1, x, domain='ZZ').decompose() [Poly(x**2 - x - 1, x, domain='ZZ'), Poly(x**2 + x, x, domain='ZZ')] """ if hasattr(f.rep, 'decompose'): result = f.rep.decompose() else: # pragma: no cover raise OperationNotSupported(f, 'decompose') return list(map(f.per, result)) def shift(f, a): """ Efficiently compute Taylor shift ``f(x + a)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).shift(2) Poly(x**2 + 2*x + 1, x, domain='ZZ') """ if hasattr(f.rep, 'shift'): result = f.rep.shift(a) else: # pragma: no cover raise OperationNotSupported(f, 'shift') return f.per(result) def sturm(f, auto=True): """ Computes the Sturm sequence of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 - 2*x**2 + x - 3, x).sturm() [Poly(x**3 - 2*x**2 + x - 3, x, domain='QQ'), Poly(3*x**2 - 4*x + 1, x, domain='QQ'), Poly(2/9*x + 25/9, x, domain='QQ'), Poly(-2079/4, x, domain='QQ')] """ if auto and f.rep.dom.has_Ring: f = f.to_field() if hasattr(f.rep, 'sturm'): result = f.rep.sturm() else: # pragma: no cover raise OperationNotSupported(f, 'sturm') return list(map(f.per, result)) def gff_list(f): """ Computes greatest factorial factorization of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**5 + 2*x**4 - x**3 - 2*x**2 >>> Poly(f).gff_list() [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)] """ if hasattr(f.rep, 'gff_list'): result = f.rep.gff_list() else: # pragma: no cover raise OperationNotSupported(f, 'gff_list') return [(f.per(g), k) for g, k in result] def sqf_norm(f): """ Computes square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> s, f, r = Poly(x**2 + 1, x, extension=[sqrt(3)]).sqf_norm() >>> s 1 >>> f Poly(x**2 - 2*sqrt(3)*x + 4, x, domain='QQ<sqrt(3)>') >>> r Poly(x**4 - 4*x**2 + 16, x, domain='QQ') """ if hasattr(f.rep, 'sqf_norm'): s, g, r = f.rep.sqf_norm() else: # pragma: no cover raise OperationNotSupported(f, 'sqf_norm') return s, f.per(g), f.per(r) def sqf_part(f): """ Computes square-free part of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 - 3*x - 2, x).sqf_part() Poly(x**2 - x - 2, x, domain='ZZ') """ if hasattr(f.rep, 'sqf_part'): result = f.rep.sqf_part() else: # pragma: no cover raise OperationNotSupported(f, 'sqf_part') return f.per(result) def sqf_list(f, all=False): """ Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16 >>> Poly(f).sqf_list() (2, [(Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) >>> Poly(f).sqf_list(all=True) (2, [(Poly(1, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) """ if hasattr(f.rep, 'sqf_list'): coeff, factors = f.rep.sqf_list(all) else: # pragma: no cover raise OperationNotSupported(f, 'sqf_list') return f.rep.dom.to_sympy(coeff), [(f.per(g), k) for g, k in factors] def sqf_list_include(f, all=False): """ Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly, expand >>> from sympy.abc import x >>> f = expand(2*(x + 1)**3*x**4) >>> f 2*x**7 + 6*x**6 + 6*x**5 + 2*x**4 >>> Poly(f).sqf_list_include() [(Poly(2, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] >>> Poly(f).sqf_list_include(all=True) [(Poly(2, x, domain='ZZ'), 1), (Poly(1, x, domain='ZZ'), 2), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] """ if hasattr(f.rep, 'sqf_list_include'): factors = f.rep.sqf_list_include(all) else: # pragma: no cover raise OperationNotSupported(f, 'sqf_list_include') return [(f.per(g), k) for g, k in factors] def factor_list(f): """ Returns a list of irreducible factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y >>> Poly(f).factor_list() (2, [(Poly(x + y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)]) """ if hasattr(f.rep, 'factor_list'): try: coeff, factors = f.rep.factor_list() except DomainError: return S.One, [(f, 1)] else: # pragma: no cover raise OperationNotSupported(f, 'factor_list') return f.rep.dom.to_sympy(coeff), [(f.per(g), k) for g, k in factors] def factor_list_include(f): """ Returns a list of irreducible factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y >>> Poly(f).factor_list_include() [(Poly(2*x + 2*y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)] """ if hasattr(f.rep, 'factor_list_include'): try: factors = f.rep.factor_list_include() except DomainError: return [(f, 1)] else: # pragma: no cover raise OperationNotSupported(f, 'factor_list_include') return [(f.per(g), k) for g, k in factors] def intervals(f, all=False, eps=None, inf=None, sup=None, fast=False, sqf=False): """ Compute isolating intervals for roots of ``f``. For real roots the Vincent-Akritas-Strzebonski (VAS) continued fractions method is used. References: =========== 1. Alkiviadis G. Akritas and Adam W. Strzebonski: A Comparative Study of Two Real Root Isolation Methods . Nonlinear Analysis: Modelling and Control, Vol. 10, No. 4, 297-304, 2005. 2. Alkiviadis G. Akritas, Adam W. Strzebonski and Panagiotis S. Vigklas: Improving the Performance of the Continued Fractions Method Using new Bounds of Positive Roots. Nonlinear Analysis: Modelling and Control, Vol. 13, No. 3, 265-279, 2008. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3, x).intervals() [((-2, -1), 1), ((1, 2), 1)] >>> Poly(x**2 - 3, x).intervals(eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] """ if eps is not None: eps = QQ.convert(eps) if eps <= 0: raise ValueError("'eps' must be a positive rational") if inf is not None: inf = QQ.convert(inf) if sup is not None: sup = QQ.convert(sup) if hasattr(f.rep, 'intervals'): result = f.rep.intervals( all=all, eps=eps, inf=inf, sup=sup, fast=fast, sqf=sqf) else: # pragma: no cover raise OperationNotSupported(f, 'intervals') if sqf: def _real(interval): s, t = interval return (QQ.to_sympy(s), QQ.to_sympy(t)) if not all: return list(map(_real, result)) def _complex(rectangle): (u, v), (s, t) = rectangle return (QQ.to_sympy(u) + I*QQ.to_sympy(v), QQ.to_sympy(s) + I*QQ.to_sympy(t)) real_part, complex_part = result return list(map(_real, real_part)), list(map(_complex, complex_part)) else: def _real(interval): (s, t), k = interval return ((QQ.to_sympy(s), QQ.to_sympy(t)), k) if not all: return list(map(_real, result)) def _complex(rectangle): ((u, v), (s, t)), k = rectangle return ((QQ.to_sympy(u) + I*QQ.to_sympy(v), QQ.to_sympy(s) + I*QQ.to_sympy(t)), k) real_part, complex_part = result return list(map(_real, real_part)), list(map(_complex, complex_part)) def refine_root(f, s, t, eps=None, steps=None, fast=False, check_sqf=False): """ Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3, x).refine_root(1, 2, eps=1e-2) (19/11, 26/15) """ if check_sqf and not f.is_sqf: raise PolynomialError("only square-free polynomials supported") s, t = QQ.convert(s), QQ.convert(t) if eps is not None: eps = QQ.convert(eps) if eps <= 0: raise ValueError("'eps' must be a positive rational") if steps is not None: steps = int(steps) elif eps is None: steps = 1 if hasattr(f.rep, 'refine_root'): S, T = f.rep.refine_root(s, t, eps=eps, steps=steps, fast=fast) else: # pragma: no cover raise OperationNotSupported(f, 'refine_root') return QQ.to_sympy(S), QQ.to_sympy(T) def count_roots(f, inf=None, sup=None): """ Return the number of roots of ``f`` in ``[inf, sup]`` interval. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**4 - 4, x).count_roots(-3, 3) 2 >>> Poly(x**4 - 4, x).count_roots(0, 1 + 3*I) 1 """ inf_real, sup_real = True, True if inf is not None: inf = sympify(inf) if inf is S.NegativeInfinity: inf = None else: re, im = inf.as_real_imag() if not im: inf = QQ.convert(inf) else: inf, inf_real = list(map(QQ.convert, (re, im))), False if sup is not None: sup = sympify(sup) if sup is S.Infinity: sup = None else: re, im = sup.as_real_imag() if not im: sup = QQ.convert(sup) else: sup, sup_real = list(map(QQ.convert, (re, im))), False if inf_real and sup_real: if hasattr(f.rep, 'count_real_roots'): count = f.rep.count_real_roots(inf=inf, sup=sup) else: # pragma: no cover raise OperationNotSupported(f, 'count_real_roots') else: if inf_real and inf is not None: inf = (inf, QQ.zero) if sup_real and sup is not None: sup = (sup, QQ.zero) if hasattr(f.rep, 'count_complex_roots'): count = f.rep.count_complex_roots(inf=inf, sup=sup) else: # pragma: no cover raise OperationNotSupported(f, 'count_complex_roots') return Integer(count) def root(f, index, radicals=True): """ Get an indexed root of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(2*x**3 - 7*x**2 + 4*x + 4) >>> f.root(0) -1/2 >>> f.root(1) 2 >>> f.root(2) 2 >>> f.root(3) Traceback (most recent call last): ... IndexError: root index out of [-3, 2] range, got 3 >>> Poly(x**5 + x + 1).root(0) RootOf(x**3 - x**2 + 1, 0) """ return sympy.polys.rootoftools.RootOf(f, index, radicals=radicals) def real_roots(f, multiple=True, radicals=True): """ Return a list of real roots with multiplicities. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).real_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).real_roots() [RootOf(x**3 + x + 1, 0)] """ reals = sympy.polys.rootoftools.RootOf.real_roots(f, radicals=radicals) if multiple: return reals else: return group(reals, multiple=False) def all_roots(f, multiple=True, radicals=True): """ Return a list of real and complex roots with multiplicities. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).all_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).all_roots() [RootOf(x**3 + x + 1, 0), RootOf(x**3 + x + 1, 1), RootOf(x**3 + x + 1, 2)] """ roots = sympy.polys.rootoftools.RootOf.all_roots(f, radicals=radicals) if multiple: return roots else: return group(roots, multiple=False) def nroots(f, n=15, maxsteps=50, cleanup=True): """ Compute numerical approximations of roots of ``f``. Parameters ========== n ... the number of digits to calculate maxsteps ... the maximum number of iterations to do If the accuracy `n` cannot be reached in `maxsteps`, it will raise an exception. You need to rerun with higher maxsteps. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3).nroots(n=15) [-1.73205080756888, 1.73205080756888] >>> Poly(x**2 - 3).nroots(n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] """ if f.is_multivariate: raise MultivariatePolynomialError( "can't compute numerical roots of %s" % f) if f.degree() <= 0: return [] # For integer and rational coefficients, convert them to integers only # (for accuracy). Otherwise just try to convert the coefficients to # mpmath.mpc and raise an exception if the conversion fails. if f.rep.dom is ZZ: coeffs = [int(coeff) for coeff in f.all_coeffs()] elif f.rep.dom is QQ: denoms = [coeff.q for coeff in f.all_coeffs()] from sympy.core.numbers import ilcm fac = ilcm(*denoms) coeffs = [int(coeff*fac) for coeff in f.all_coeffs()] else: coeffs = [coeff.evalf(n=n).as_real_imag() for coeff in f.all_coeffs()] try: coeffs = [sympy.mpmath.mpc(*coeff) for coeff in coeffs] except TypeError: raise DomainError("Numerical domain expected, got %s" % \ f.rep.dom) dps = sympy.mpmath.mp.dps sympy.mpmath.mp.dps = n try: # We need to add extra precision to guard against losing accuracy. # 10 times the degree of the polynomial seems to work well. roots = sympy.mpmath.polyroots(coeffs, maxsteps=maxsteps, cleanup=cleanup, error=False, extraprec=f.degree()*10) # Mpmath puts real roots first, then complex ones (as does all_roots) # so we make sure this convention holds here, too. roots = list(map(sympify, sorted(roots, key=lambda r: (1 if r.imag else 0, r.real, r.imag)))) except NoConvergence: raise NoConvergence( 'convergence to root failed; try n < %s or maxsteps > %s' % ( n, maxsteps)) finally: sympy.mpmath.mp.dps = dps return roots def ground_roots(f): """ Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**6 - 4*x**4 + 4*x**3 - x**2).ground_roots() {0: 2, 1: 2} """ if f.is_multivariate: raise MultivariatePolynomialError( "can't compute ground roots of %s" % f) roots = {} for factor, k in f.factor_list()[1]: if factor.is_linear: a, b = factor.all_coeffs() roots[-b/a] = k return roots def nth_power_roots_poly(f, n): """ Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**4 - x**2 + 1) >>> f.nth_power_roots_poly(2) Poly(x**4 - 2*x**3 + 3*x**2 - 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(3) Poly(x**4 + 2*x**2 + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(4) Poly(x**4 + 2*x**3 + 3*x**2 + 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(12) Poly(x**4 - 4*x**3 + 6*x**2 - 4*x + 1, x, domain='ZZ') """ if f.is_multivariate: raise MultivariatePolynomialError( "must be a univariate polynomial") N = sympify(n) if N.is_Integer and N >= 1: n = int(N) else: raise ValueError("'n' must an integer and n >= 1, got %s" % n) x = f.gen t = Dummy('t') r = f.resultant(f.__class__.from_expr(x**n - t, x, t)) return r.replace(t, x) def cancel(f, g, include=False): """ Cancel common factors in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x)) (1, Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x), include=True) (Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) """ dom, per, F, G = f._unify(g) if hasattr(F, 'cancel'): result = F.cancel(G, include=include) else: # pragma: no cover raise OperationNotSupported(f, 'cancel') if not include: if dom.has_assoc_Ring: dom = dom.get_ring() cp, cq, p, q = result cp = dom.to_sympy(cp) cq = dom.to_sympy(cq) return cp/cq, per(p), per(q) else: return tuple(map(per, result)) @property def is_zero(f): """ Returns ``True`` if ``f`` is a zero polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_zero True >>> Poly(1, x).is_zero False """ return f.rep.is_zero @property def is_one(f): """ Returns ``True`` if ``f`` is a unit polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_one False >>> Poly(1, x).is_one True """ return f.rep.is_one @property def is_sqf(f): """ Returns ``True`` if ``f`` is a square-free polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).is_sqf False >>> Poly(x**2 - 1, x).is_sqf True """ return f.rep.is_sqf @property def is_monic(f): """ Returns ``True`` if the leading coefficient of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 2, x).is_monic True >>> Poly(2*x + 2, x).is_monic False """ return f.rep.is_monic @property def is_primitive(f): """ Returns ``True`` if GCD of the coefficients of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 6*x + 12, x).is_primitive False >>> Poly(x**2 + 3*x + 6, x).is_primitive True """ return f.rep.is_primitive @property def is_ground(f): """ Returns ``True`` if ``f`` is an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x, x).is_ground False >>> Poly(2, x).is_ground True >>> Poly(y, x).is_ground True """ return f.rep.is_ground @property def is_linear(f): """ Returns ``True`` if ``f`` is linear in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x + y + 2, x, y).is_linear True >>> Poly(x*y + 2, x, y).is_linear False """ return f.rep.is_linear @property def is_quadratic(f): """ Returns ``True`` if ``f`` is quadratic in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x*y + 2, x, y).is_quadratic True >>> Poly(x*y**2 + 2, x, y).is_quadratic False """ return f.rep.is_quadratic @property def is_monomial(f): """ Returns ``True`` if ``f`` is zero or has only one term. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(3*x**2, x).is_monomial True >>> Poly(3*x**2 + 1, x).is_monomial False """ return f.rep.is_monomial @property def is_homogeneous(f): """ Returns ``True`` if ``f`` is a homogeneous polynomial. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x*y, x, y).is_homogeneous True >>> Poly(x**3 + x*y, x, y).is_homogeneous False """ return f.rep.is_homogeneous @property def is_irreducible(f): """ Returns ``True`` if ``f`` has no factors over its domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x + 1, x, modulus=2).is_irreducible True >>> Poly(x**2 + 1, x, modulus=2).is_irreducible False """ return f.rep.is_irreducible @property def is_univariate(f): """ Returns ``True`` if ``f`` is a univariate polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x + 1, x).is_univariate True >>> Poly(x*y**2 + x*y + 1, x, y).is_univariate False >>> Poly(x*y**2 + x*y + 1, x).is_univariate True >>> Poly(x**2 + x + 1, x, y).is_univariate False """ return len(f.gens) == 1 @property def is_multivariate(f): """ Returns ``True`` if ``f`` is a multivariate polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x + 1, x).is_multivariate False >>> Poly(x*y**2 + x*y + 1, x, y).is_multivariate True >>> Poly(x*y**2 + x*y + 1, x).is_multivariate False >>> Poly(x**2 + x + 1, x, y).is_multivariate True """ return len(f.gens) != 1 @property def is_cyclotomic(f): """ Returns ``True`` if ``f`` is a cyclotomic polnomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1 >>> Poly(f).is_cyclotomic False >>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1 >>> Poly(g).is_cyclotomic True """ return f.rep.is_cyclotomic def __abs__(f): return f.abs() def __neg__(f): return f.neg() @_sympifyit('g', NotImplemented) def __add__(f, g): if not g.is_Poly: try: g = f.__class__(g, *f.gens) except PolynomialError: return f.as_expr() + g return f.add(g) @_sympifyit('g', NotImplemented) def __radd__(f, g): if not g.is_Poly: try: g = f.__class__(g, *f.gens) except PolynomialError: return g + f.as_expr() return g.add(f) @_sympifyit('g', NotImplemented) def __sub__(f, g): if not g.is_Poly: try: g = f.__class__(g, *f.gens) except PolynomialError: return f.as_expr() - g return f.sub(g) @_sympifyit('g', NotImplemented) def __rsub__(f, g): if not g.is_Poly: try: g = f.__class__(g, *f.gens) except PolynomialError: return g - f.as_expr() return g.sub(f) @_sympifyit('g', NotImplemented) def __mul__(f, g): if not g.is_Poly: try: g = f.__class__(g, *f.gens) except PolynomialError: return f.as_expr()*g return f.mul(g) @_sympifyit('g', NotImplemented) def __rmul__(f, g): if not g.is_Poly: try: g = f.__class__(g, *f.gens) except PolynomialError: return g*f.as_expr() return g.mul(f) @_sympifyit('n', NotImplemented) def __pow__(f, n): if n.is_Integer and n >= 0: return f.pow(n) else: return f.as_expr()**n @_sympifyit('g', NotImplemented) def __divmod__(f, g): if not g.is_Poly: g = f.__class__(g, *f.gens) return f.div(g) @_sympifyit('g', NotImplemented) def __rdivmod__(f, g): if not g.is_Poly: g = f.__class__(g, *f.gens) return g.div(f) @_sympifyit('g', NotImplemented) def __mod__(f, g): if not g.is_Poly: g = f.__class__(g, *f.gens) return f.rem(g) @_sympifyit('g', NotImplemented) def __rmod__(f, g): if not g.is_Poly: g = f.__class__(g, *f.gens) return g.rem(f) @_sympifyit('g', NotImplemented) def __floordiv__(f, g): if not g.is_Poly: g = f.__class__(g, *f.gens) return f.quo(g) @_sympifyit('g', NotImplemented) def __rfloordiv__(f, g): if not g.is_Poly: g = f.__class__(g, *f.gens) return g.quo(f) @_sympifyit('g', NotImplemented) def __div__(f, g): return f.as_expr()/g.as_expr() @_sympifyit('g', NotImplemented) def __rdiv__(f, g): return g.as_expr()/f.as_expr() __truediv__ = __div__ __rtruediv__ = __rdiv__ @_sympifyit('g', NotImplemented) def __eq__(f, g): if not g.is_Poly: try: g = f.__class__(g, f.gens, domain=f.get_domain()) except (PolynomialError, DomainError, CoercionFailed): return False if f.gens != g.gens: return False if f.rep.dom != g.rep.dom: try: dom = f.rep.dom.unify(g.rep.dom, f.gens) except UnificationFailed: return False f = f.set_domain(dom) g = g.set_domain(dom) return f.rep == g.rep @_sympifyit('g', NotImplemented) def __ne__(f, g): return not f.__eq__(g) def __nonzero__(f): return not f.is_zero __bool__ = __nonzero__ def eq(f, g, strict=False): if not strict: return f.__eq__(g) else: return f._strict_eq(sympify(g)) def ne(f, g, strict=False): return not f.eq(g, strict=strict) def _strict_eq(f, g): return isinstance(g, f.__class__) and f.gens == g.gens and f.rep.eq(g.rep, strict=True) @public class PurePoly(Poly): """Class for representing pure polynomials. """ def _hashable_content(self): """Allow SymPy to hash Poly instances. """ return (self.rep,) def __hash__(self): return super(PurePoly, self).__hash__() @property def free_symbols(self): """ Free symbols of a polynomial. Examples ======== >>> from sympy import PurePoly >>> from sympy.abc import x, y >>> PurePoly(x**2 + 1).free_symbols set() >>> PurePoly(x**2 + y).free_symbols set() >>> PurePoly(x**2 + y, x).free_symbols set([y]) """ return self.free_symbols_in_domain @_sympifyit('g', NotImplemented) def __eq__(f, g): if not g.is_Poly: try: g = f.__class__(g, f.gens, domain=f.get_domain()) except (PolynomialError, DomainError, CoercionFailed): return False if len(f.gens) != len(g.gens): return False if f.rep.dom != g.rep.dom: try: dom = f.rep.dom.unify(g.rep.dom, f.gens) except UnificationFailed: return False f = f.set_domain(dom) g = g.set_domain(dom) return f.rep == g.rep def _strict_eq(f, g): return isinstance(g, f.__class__) and f.rep.eq(g.rep, strict=True) def _unify(f, g): g = sympify(g) if not g.is_Poly: try: return f.rep.dom, f.per, f.rep, f.rep.per(f.rep.dom.from_sympy(g)) except CoercionFailed: raise UnificationFailed("can't unify %s with %s" % (f, g)) if len(f.gens) != len(g.gens): raise UnificationFailed("can't unify %s with %s" % (f, g)) if not (isinstance(f.rep, DMP) and isinstance(g.rep, DMP)): raise UnificationFailed("can't unify %s with %s" % (f, g)) cls = f.__class__ gens = f.gens dom = f.rep.dom.unify(g.rep.dom, gens) F = f.rep.convert(dom) G = g.rep.convert(dom) def per(rep, dom=dom, gens=gens, remove=None): if remove is not None: gens = gens[:remove] + gens[remove + 1:] if not gens: return dom.to_sympy(rep) return cls.new(rep, *gens) return dom, per, F, G @public def poly_from_expr(expr, *gens, **args): """Construct a polynomial from an expression. """ opt = options.build_options(gens, args) return _poly_from_expr(expr, opt) def _poly_from_expr(expr, opt): """Construct a polynomial from an expression. """ orig, expr = expr, sympify(expr) if not isinstance(expr, Basic): raise PolificationFailed(opt, orig, expr) elif expr.is_Poly: poly = expr.__class__._from_poly(expr, opt) opt.gens = poly.gens opt.domain = poly.domain if opt.polys is None: opt.polys = True return poly, opt elif opt.expand: expr = expr.expand() try: rep, opt = _dict_from_expr(expr, opt) except GeneratorsNeeded: raise PolificationFailed(opt, orig, expr) monoms, coeffs = list(zip(*list(rep.items()))) domain = opt.domain if domain is None: opt.domain, coeffs = construct_domain(coeffs, opt=opt) else: coeffs = list(map(domain.from_sympy, coeffs)) rep = dict(list(zip(monoms, coeffs))) poly = Poly._from_dict(rep, opt) if opt.polys is None: opt.polys = False return poly, opt @public def parallel_poly_from_expr(exprs, *gens, **args): """Construct polynomials from expressions. """ opt = options.build_options(gens, args) return _parallel_poly_from_expr(exprs, opt) def _parallel_poly_from_expr(exprs, opt): """Construct polynomials from expressions. """ if len(exprs) == 2: f, g = exprs if isinstance(f, Poly) and isinstance(g, Poly): f = f.__class__._from_poly(f, opt) g = g.__class__._from_poly(g, opt) f, g = f.unify(g) opt.gens = f.gens opt.domain = f.domain if opt.polys is None: opt.polys = True return [f, g], opt origs, exprs = list(exprs), [] _exprs, _polys = [], [] failed = False for i, expr in enumerate(origs): expr = sympify(expr) if isinstance(expr, Basic): if expr.is_Poly: _polys.append(i) else: _exprs.append(i) if opt.expand: expr = expr.expand() else: failed = True exprs.append(expr) if failed: raise PolificationFailed(opt, origs, exprs, True) if _polys: # XXX: this is a temporary solution for i in _polys: exprs[i] = exprs[i].as_expr() try: reps, opt = _parallel_dict_from_expr(exprs, opt) except GeneratorsNeeded: raise PolificationFailed(opt, origs, exprs, True) for k in opt.gens: if isinstance(k, Piecewise): raise PolynomialError("Piecewise generators do not make sense") coeffs_list, lengths = [], [] all_monoms = [] all_coeffs = [] for rep in reps: monoms, coeffs = list(zip(*list(rep.items()))) coeffs_list.extend(coeffs) all_monoms.append(monoms) lengths.append(len(coeffs)) domain = opt.domain if domain is None: opt.domain, coeffs_list = construct_domain(coeffs_list, opt=opt) else: coeffs_list = list(map(domain.from_sympy, coeffs_list)) for k in lengths: all_coeffs.append(coeffs_list[:k]) coeffs_list = coeffs_list[k:] polys = [] for monoms, coeffs in zip(all_monoms, all_coeffs): rep = dict(list(zip(monoms, coeffs))) poly = Poly._from_dict(rep, opt) polys.append(poly) if opt.polys is None: opt.polys = bool(_polys) return polys, opt def _update_args(args, key, value): """Add a new ``(key, value)`` pair to arguments ``dict``. """ args = dict(args) if key not in args: args[key] = value return args @public def degree(f, *gens, **args): """ Return the degree of ``f`` in the given variable. The degree of 0 is negative infinity. Examples ======== >>> from sympy import degree >>> from sympy.abc import x, y >>> degree(x**2 + y*x + 1, gen=x) 2 >>> degree(x**2 + y*x + 1, gen=y) 1 >>> degree(0, x) -oo """ options.allowed_flags(args, ['gen', 'polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('degree', 1, exc) return sympify(F.degree(opt.gen)) @public def degree_list(f, *gens, **args): """ Return a list of degrees of ``f`` in all variables. Examples ======== >>> from sympy import degree_list >>> from sympy.abc import x, y >>> degree_list(x**2 + y*x + 1) (2, 1) """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('degree_list', 1, exc) degrees = F.degree_list() return tuple(map(Integer, degrees)) @public def LC(f, *gens, **args): """ Return the leading coefficient of ``f``. Examples ======== >>> from sympy import LC >>> from sympy.abc import x, y >>> LC(4*x**2 + 2*x*y**2 + x*y + 3*y) 4 """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('LC', 1, exc) return F.LC(order=opt.order) @public def LM(f, *gens, **args): """ Return the leading monomial of ``f``. Examples ======== >>> from sympy import LM >>> from sympy.abc import x, y >>> LM(4*x**2 + 2*x*y**2 + x*y + 3*y) x**2 """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('LM', 1, exc) monom = F.LM(order=opt.order) return monom.as_expr() @public def LT(f, *gens, **args): """ Return the leading term of ``f``. Examples ======== >>> from sympy import LT >>> from sympy.abc import x, y >>> LT(4*x**2 + 2*x*y**2 + x*y + 3*y) 4*x**2 """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('LT', 1, exc) monom, coeff = F.LT(order=opt.order) return coeff*monom.as_expr() @public def pdiv(f, g, *gens, **args): """ Compute polynomial pseudo-division of ``f`` and ``g``. Examples ======== >>> from sympy import pdiv >>> from sympy.abc import x >>> pdiv(x**2 + 1, 2*x - 4) (2*x + 4, 20) """ options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('pdiv', 2, exc) q, r = F.pdiv(G) if not opt.polys: return q.as_expr(), r.as_expr() else: return q, r @public def prem(f, g, *gens, **args): """ Compute polynomial pseudo-remainder of ``f`` and ``g``. Examples ======== >>> from sympy import prem >>> from sympy.abc import x >>> prem(x**2 + 1, 2*x - 4) 20 """ options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('prem', 2, exc) r = F.prem(G) if not opt.polys: return r.as_expr() else: return r @public def pquo(f, g, *gens, **args): """ Compute polynomial pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pquo >>> from sympy.abc import x >>> pquo(x**2 + 1, 2*x - 4) 2*x + 4 >>> pquo(x**2 - 1, 2*x - 1) 2*x + 1 """ options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('pquo', 2, exc) try: q = F.pquo(G) except ExactQuotientFailed: raise ExactQuotientFailed(f, g) if not opt.polys: return q.as_expr() else: return q @public def pexquo(f, g, *gens, **args): """ Compute polynomial exact pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pexquo >>> from sympy.abc import x >>> pexquo(x**2 - 1, 2*x - 2) 2*x + 2 >>> pexquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 """ options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('pexquo', 2, exc) q = F.pexquo(G) if not opt.polys: return q.as_expr() else: return q @public def div(f, g, *gens, **args): """ Compute polynomial division of ``f`` and ``g``. Examples ======== >>> from sympy import div, ZZ, QQ >>> from sympy.abc import x >>> div(x**2 + 1, 2*x - 4, domain=ZZ) (0, x**2 + 1) >>> div(x**2 + 1, 2*x - 4, domain=QQ) (x/2 + 1, 5) """ options.allowed_flags(args, ['auto', 'polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('div', 2, exc) q, r = F.div(G, auto=opt.auto) if not opt.polys: return q.as_expr(), r.as_expr() else: return q, r @public def rem(f, g, *gens, **args): """ Compute polynomial remainder of ``f`` and ``g``. Examples ======== >>> from sympy import rem, ZZ, QQ >>> from sympy.abc import x >>> rem(x**2 + 1, 2*x - 4, domain=ZZ) x**2 + 1 >>> rem(x**2 + 1, 2*x - 4, domain=QQ) 5 """ options.allowed_flags(args, ['auto', 'polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('rem', 2, exc) r = F.rem(G, auto=opt.auto) if not opt.polys: return r.as_expr() else: return r @public def quo(f, g, *gens, **args): """ Compute polynomial quotient of ``f`` and ``g``. Examples ======== >>> from sympy import quo >>> from sympy.abc import x >>> quo(x**2 + 1, 2*x - 4) x/2 + 1 >>> quo(x**2 - 1, x - 1) x + 1 """ options.allowed_flags(args, ['auto', 'polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('quo', 2, exc) q = F.quo(G, auto=opt.auto) if not opt.polys: return q.as_expr() else: return q @public def exquo(f, g, *gens, **args): """ Compute polynomial exact quotient of ``f`` and ``g``. Examples ======== >>> from sympy import exquo >>> from sympy.abc import x >>> exquo(x**2 - 1, x - 1) x + 1 >>> exquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 """ options.allowed_flags(args, ['auto', 'polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('exquo', 2, exc) q = F.exquo(G, auto=opt.auto) if not opt.polys: return q.as_expr() else: return q @public def half_gcdex(f, g, *gens, **args): """ Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import half_gcdex >>> from sympy.abc import x >>> half_gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (-x/5 + 3/5, x + 1) """ options.allowed_flags(args, ['auto', 'polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: domain, (a, b) = construct_domain(exc.exprs) try: s, h = domain.half_gcdex(a, b) except NotImplementedError: raise ComputationFailed('half_gcdex', 2, exc) else: return domain.to_sympy(s), domain.to_sympy(h) s, h = F.half_gcdex(G, auto=opt.auto) if not opt.polys: return s.as_expr(), h.as_expr() else: return s, h @public def gcdex(f, g, *gens, **args): """ Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import gcdex >>> from sympy.abc import x >>> gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (-x/5 + 3/5, x**2/5 - 6*x/5 + 2, x + 1) """ options.allowed_flags(args, ['auto', 'polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: domain, (a, b) = construct_domain(exc.exprs) try: s, t, h = domain.gcdex(a, b) except NotImplementedError: raise ComputationFailed('gcdex', 2, exc) else: return domain.to_sympy(s), domain.to_sympy(t), domain.to_sympy(h) s, t, h = F.gcdex(G, auto=opt.auto) if not opt.polys: return s.as_expr(), t.as_expr(), h.as_expr() else: return s, t, h @public def invert(f, g, *gens, **args): """ Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert >>> from sympy.abc import x >>> invert(x**2 - 1, 2*x - 1) -4/3 >>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor """ options.allowed_flags(args, ['auto', 'polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: domain, (a, b) = construct_domain(exc.exprs) try: return domain.to_sympy(domain.invert(a, b)) except NotImplementedError: raise ComputationFailed('invert', 2, exc) h = F.invert(G, auto=opt.auto) if not opt.polys: return h.as_expr() else: return h @public def subresultants(f, g, *gens, **args): """ Compute subresultant PRS of ``f`` and ``g``. Examples ======== >>> from sympy import subresultants >>> from sympy.abc import x >>> subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2] """ options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('subresultants', 2, exc) result = F.subresultants(G) if not opt.polys: return [r.as_expr() for r in result] else: return result @public def resultant(f, g, *gens, **args): """ Compute resultant of ``f`` and ``g``. Examples ======== >>> from sympy import resultant >>> from sympy.abc import x >>> resultant(x**2 + 1, x**2 - 1) 4 """ includePRS = args.pop('includePRS', False) options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('resultant', 2, exc) if includePRS: result, R = F.resultant(G, includePRS=includePRS) else: result = F.resultant(G) if not opt.polys: if includePRS: return result.as_expr(), [r.as_expr() for r in R] return result.as_expr() else: if includePRS: return result, R return result @public def discriminant(f, *gens, **args): """ Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('discriminant', 1, exc) result = F.discriminant() if not opt.polys: return result.as_expr() else: return result @public def cofactors(f, g, *gens, **args): """ Compute GCD and cofactors of ``f`` and ``g``. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import cofactors >>> from sympy.abc import x >>> cofactors(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) """ options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: domain, (a, b) = construct_domain(exc.exprs) try: h, cff, cfg = domain.cofactors(a, b) except NotImplementedError: raise ComputationFailed('cofactors', 2, exc) else: return domain.to_sympy(h), domain.to_sympy(cff), domain.to_sympy(cfg) h, cff, cfg = F.cofactors(G) if not opt.polys: return h.as_expr(), cff.as_expr(), cfg.as_expr() else: return h, cff, cfg @public def gcd_list(seq, *gens, **args): """ Compute GCD of a list of polynomials. Examples ======== >>> from sympy import gcd_list >>> from sympy.abc import x >>> gcd_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x - 1 """ seq = sympify(seq) if not gens and not args: domain, numbers = construct_domain(seq) if not numbers: return domain.zero elif domain.is_Numerical: result, numbers = numbers[0], numbers[1:] for number in numbers: result = domain.gcd(result, number) if domain.is_one(result): break return domain.to_sympy(result) options.allowed_flags(args, ['polys']) try: polys, opt = parallel_poly_from_expr(seq, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('gcd_list', len(seq), exc) if not polys: if not opt.polys: return S.Zero else: return Poly(0, opt=opt) result, polys = polys[0], polys[1:] for poly in polys: result = result.gcd(poly) if result.is_one: break if not opt.polys: return result.as_expr() else: return result @public def gcd(f, g=None, *gens, **args): """ Compute GCD of ``f`` and ``g``. Examples ======== >>> from sympy import gcd >>> from sympy.abc import x >>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 """ if hasattr(f, '__iter__'): if g is not None: gens = (g,) + gens return gcd_list(f, *gens, **args) elif g is None: raise TypeError("gcd() takes 2 arguments or a sequence of arguments") options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: domain, (a, b) = construct_domain(exc.exprs) try: return domain.to_sympy(domain.gcd(a, b)) except NotImplementedError: raise ComputationFailed('gcd', 2, exc) result = F.gcd(G) if not opt.polys: return result.as_expr() else: return result @public def lcm_list(seq, *gens, **args): """ Compute LCM of a list of polynomials. Examples ======== >>> from sympy import lcm_list >>> from sympy.abc import x >>> lcm_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x**5 - x**4 - 2*x**3 - x**2 + x + 2 """ seq = sympify(seq) if not gens and not args: domain, numbers = construct_domain(seq) if not numbers: return domain.one elif domain.is_Numerical: result, numbers = numbers[0], numbers[1:] for number in numbers: result = domain.lcm(result, number) return domain.to_sympy(result) options.allowed_flags(args, ['polys']) try: polys, opt = parallel_poly_from_expr(seq, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('lcm_list', len(seq), exc) if not polys: if not opt.polys: return S.One else: return Poly(1, opt=opt) result, polys = polys[0], polys[1:] for poly in polys: result = result.lcm(poly) if not opt.polys: return result.as_expr() else: return result @public def lcm(f, g=None, *gens, **args): """ Compute LCM of ``f`` and ``g``. Examples ======== >>> from sympy import lcm >>> from sympy.abc import x >>> lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2 """ if hasattr(f, '__iter__'): if g is not None: gens = (g,) + gens return lcm_list(f, *gens, **args) elif g is None: raise TypeError("lcm() takes 2 arguments or a sequence of arguments") options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: domain, (a, b) = construct_domain(exc.exprs) try: return domain.to_sympy(domain.lcm(a, b)) except NotImplementedError: raise ComputationFailed('lcm', 2, exc) result = F.lcm(G) if not opt.polys: return result.as_expr() else: return result @public def terms_gcd(f, *gens, **args): """ Remove GCD of terms from ``f``. If the ``deep`` flag is True, then the arguments of ``f`` will have terms_gcd applied to them. If a fraction is factored out of ``f`` and ``f`` is an Add, then an unevaluated Mul will be returned so that automatic simplification does not redistribute it. The hint ``clear``, when set to False, can be used to prevent such factoring when all coefficients are not fractions. Examples ======== >>> from sympy import terms_gcd, cos >>> from sympy.abc import x, y >>> terms_gcd(x**6*y**2 + x**3*y, x, y) x**3*y*(x**3*y + 1) The default action of polys routines is to expand the expression given to them. terms_gcd follows this behavior: >>> terms_gcd((3+3*x)*(x+x*y)) 3*x*(x*y + x + y + 1) If this is not desired then the hint ``expand`` can be set to False. In this case the expression will be treated as though it were comprised of one or more terms: >>> terms_gcd((3+3*x)*(x+x*y), expand=False) (3*x + 3)*(x*y + x) In order to traverse factors of a Mul or the arguments of other functions, the ``deep`` hint can be used: >>> terms_gcd((3 + 3*x)*(x + x*y), expand=False, deep=True) 3*x*(x + 1)*(y + 1) >>> terms_gcd(cos(x + x*y), deep=True) cos(x*(y + 1)) Rationals are factored out by default: >>> terms_gcd(x + y/2) (2*x + y)/2 Only the y-term had a coefficient that was a fraction; if one does not want to factor out the 1/2 in cases like this, the flag ``clear`` can be set to False: >>> terms_gcd(x + y/2, clear=False) x + y/2 >>> terms_gcd(x*y/2 + y**2, clear=False) y*(x/2 + y) The ``clear`` flag is ignored if all coefficients are fractions: >>> terms_gcd(x/3 + y/2, clear=False) (2*x + 3*y)/6 See Also ======== sympy.core.exprtools.gcd_terms, sympy.core.exprtools.factor_terms """ from sympy.core.relational import Equality orig = sympify(f) if not isinstance(f, Expr) or f.is_Atom: return orig if args.get('deep', False): new = f.func(*[terms_gcd(a, *gens, **args) for a in f.args]) args.pop('deep') args['expand'] = False return terms_gcd(new, *gens, **args) if isinstance(f, Equality): return f clear = args.pop('clear', True) options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: return exc.expr J, f = F.terms_gcd() if opt.domain.has_Ring: if opt.domain.has_Field: denom, f = f.clear_denoms(convert=True) coeff, f = f.primitive() if opt.domain.has_Field: coeff /= denom else: coeff = S.One term = Mul(*[x**j for x, j in zip(f.gens, J)]) if coeff == 1: coeff = S.One if term == 1: return orig if clear: return _keep_coeff(coeff, term*f.as_expr()) # base the clearing on the form of the original expression, not # the (perhaps) Mul that we have now coeff, f = _keep_coeff(coeff, f.as_expr(), clear=False).as_coeff_Mul() return _keep_coeff(coeff, term*f, clear=False) @public def trunc(f, p, *gens, **args): """ Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import trunc >>> from sympy.abc import x >>> trunc(2*x**3 + 3*x**2 + 5*x + 7, 3) -x**3 - x + 1 """ options.allowed_flags(args, ['auto', 'polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('trunc', 1, exc) result = F.trunc(sympify(p)) if not opt.polys: return result.as_expr() else: return result @public def monic(f, *gens, **args): """ Divide all coefficients of ``f`` by ``LC(f)``. Examples ======== >>> from sympy import monic >>> from sympy.abc import x >>> monic(3*x**2 + 4*x + 2) x**2 + 4*x/3 + 2/3 """ options.allowed_flags(args, ['auto', 'polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('monic', 1, exc) result = F.monic(auto=opt.auto) if not opt.polys: return result.as_expr() else: return result @public def content(f, *gens, **args): """ Compute GCD of coefficients of ``f``. Examples ======== >>> from sympy import content >>> from sympy.abc import x >>> content(6*x**2 + 8*x + 12) 2 """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('content', 1, exc) return F.content() @public def primitive(f, *gens, **args): """ Compute content and the primitive form of ``f``. Examples ======== >>> from sympy.polys.polytools import primitive >>> from sympy.abc import x >>> primitive(6*x**2 + 8*x + 12) (2, 3*x**2 + 4*x + 6) >>> eq = (2 + 2*x)*x + 2 Expansion is performed by default: >>> primitive(eq) (2, x**2 + x + 1) Set ``expand`` to False to shut this off. Note that the extraction will not be recursive; use the as_content_primitive method for recursive, non-destructive Rational extraction. >>> primitive(eq, expand=False) (1, x*(2*x + 2) + 2) >>> eq.as_content_primitive() (2, x*(x + 1) + 1) """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('primitive', 1, exc) cont, result = F.primitive() if not opt.polys: return cont, result.as_expr() else: return cont, result @public def compose(f, g, *gens, **args): """ Compute functional composition ``f(g)``. Examples ======== >>> from sympy import compose >>> from sympy.abc import x >>> compose(x**2 + x, x - 1) x**2 - x """ options.allowed_flags(args, ['polys']) try: (F, G), opt = parallel_poly_from_expr((f, g), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('compose', 2, exc) result = F.compose(G) if not opt.polys: return result.as_expr() else: return result @public def decompose(f, *gens, **args): """ Compute functional decomposition of ``f``. Examples ======== >>> from sympy import decompose >>> from sympy.abc import x >>> decompose(x**4 + 2*x**3 - x - 1) [x**2 - x - 1, x**2 + x] """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('decompose', 1, exc) result = F.decompose() if not opt.polys: return [r.as_expr() for r in result] else: return result @public def sturm(f, *gens, **args): """ Compute Sturm sequence of ``f``. Examples ======== >>> from sympy import sturm >>> from sympy.abc import x >>> sturm(x**3 - 2*x**2 + x - 3) [x**3 - 2*x**2 + x - 3, 3*x**2 - 4*x + 1, 2*x/9 + 25/9, -2079/4] """ options.allowed_flags(args, ['auto', 'polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('sturm', 1, exc) result = F.sturm(auto=opt.auto) if not opt.polys: return [r.as_expr() for r in result] else: return result @public def gff_list(f, *gens, **args): """ Compute a list of greatest factorial factors of ``f``. Examples ======== >>> from sympy import gff_list, ff >>> from sympy.abc import x >>> f = x**5 + 2*x**4 - x**3 - 2*x**2 >>> gff_list(f) [(x, 1), (x + 2, 4)] >>> (ff(x, 1)*ff(x + 2, 4)).expand() == f True """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('gff_list', 1, exc) factors = F.gff_list() if not opt.polys: return [(g.as_expr(), k) for g, k in factors] else: return factors @public def gff(f, *gens, **args): """Compute greatest factorial factorization of ``f``. """ raise NotImplementedError('symbolic falling factorial') @public def sqf_norm(f, *gens, **args): """ Compute square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import sqf_norm, sqrt >>> from sympy.abc import x >>> sqf_norm(x**2 + 1, extension=[sqrt(3)]) (1, x**2 - 2*sqrt(3)*x + 4, x**4 - 4*x**2 + 16) """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('sqf_norm', 1, exc) s, g, r = F.sqf_norm() if not opt.polys: return Integer(s), g.as_expr(), r.as_expr() else: return Integer(s), g, r @public def sqf_part(f, *gens, **args): """ Compute square-free part of ``f``. Examples ======== >>> from sympy import sqf_part >>> from sympy.abc import x >>> sqf_part(x**3 - 3*x - 2) x**2 - x - 2 """ options.allowed_flags(args, ['polys']) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('sqf_part', 1, exc) result = F.sqf_part() if not opt.polys: return result.as_expr() else: return result def _sorted_factors(factors, method): """Sort a list of ``(expr, exp)`` pairs. """ if method == 'sqf': def key(obj): poly, exp = obj rep = poly.rep.rep return (exp, len(rep), rep) else: def key(obj): poly, exp = obj rep = poly.rep.rep return (len(rep), exp, rep) return sorted(factors, key=key) def _factors_product(factors): """Multiply a list of ``(expr, exp)`` pairs. """ return Mul(*[f.as_expr()**k for f, k in factors]) def _symbolic_factor_list(expr, opt, method): """Helper function for :func:`_symbolic_factor`. """ coeff, factors = S.One, [] for arg in Mul.make_args(expr): if arg.is_Number: coeff *= arg continue elif arg.is_Pow: base, exp = arg.args if base.is_Number: factors.append((base, exp)) continue else: base, exp = arg, S.One try: poly, _ = _poly_from_expr(base, opt) except PolificationFailed as exc: factors.append((exc.expr, exp)) else: func = getattr(poly, method + '_list') _coeff, _factors = func() if _coeff is not S.One: if exp.is_Integer: coeff *= _coeff**exp elif _coeff.is_positive: factors.append((_coeff, exp)) else: _factors.append((_coeff, S.One)) if exp is S.One: factors.extend(_factors) elif exp.is_integer: factors.extend([(f, k*exp) for f, k in _factors]) else: other = [] for f, k in _factors: if f.as_expr().is_positive: factors.append((f, k*exp)) else: other.append((f, k)) factors.append((_factors_product(other), exp)) return coeff, factors def _symbolic_factor(expr, opt, method): """Helper function for :func:`_factor`. """ if isinstance(expr, Expr) and not expr.is_Relational: if hasattr(expr,'_eval_factor'): return expr._eval_factor() coeff, factors = _symbolic_factor_list(together(expr), opt, method) return _keep_coeff(coeff, _factors_product(factors)) elif hasattr(expr, 'args'): return expr.func(*[_symbolic_factor(arg, opt, method) for arg in expr.args]) elif hasattr(expr, '__iter__'): return expr.__class__([_symbolic_factor(arg, opt, method) for arg in expr]) else: return expr def _generic_factor_list(expr, gens, args, method): """Helper function for :func:`sqf_list` and :func:`factor_list`. """ options.allowed_flags(args, ['frac', 'polys']) opt = options.build_options(gens, args) expr = sympify(expr) if isinstance(expr, Expr) and not expr.is_Relational: numer, denom = together(expr).as_numer_denom() cp, fp = _symbolic_factor_list(numer, opt, method) cq, fq = _symbolic_factor_list(denom, opt, method) if fq and not opt.frac: raise PolynomialError("a polynomial expected, got %s" % expr) _opt = opt.clone(dict(expand=True)) for factors in (fp, fq): for i, (f, k) in enumerate(factors): if not f.is_Poly: f, _ = _poly_from_expr(f, _opt) factors[i] = (f, k) fp = _sorted_factors(fp, method) fq = _sorted_factors(fq, method) if not opt.polys: fp = [(f.as_expr(), k) for f, k in fp] fq = [(f.as_expr(), k) for f, k in fq] coeff = cp/cq if not opt.frac: return coeff, fp else: return coeff, fp, fq else: raise PolynomialError("a polynomial expected, got %s" % expr) def _generic_factor(expr, gens, args, method): """Helper function for :func:`sqf` and :func:`factor`. """ options.allowed_flags(args, []) opt = options.build_options(gens, args) return _symbolic_factor(sympify(expr), opt, method) def to_rational_coeffs(f): """ try to transform a polynomial to have rational coefficients try to find a transformation ``x = alpha*y`` ``f(x) = lc*alpha**n * g(y)`` where ``g`` is a polynomial with rational coefficients, ``lc`` the leading coefficient. If this fails, try ``x = y + beta`` ``f(x) = g(y)`` Returns ``None`` if ``g`` not found; ``(lc, alpha, None, g)`` in case of rescaling ``(None, None, beta, g)`` in case of translation Notes ===== Currently it transforms only polynomials without roots larger than 2. Examples ======== >>> from sympy import sqrt, Poly, simplify >>> from sympy.polys.polytools import to_rational_coeffs >>> from sympy.abc import x >>> p = Poly(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))}), x, domain='EX') >>> lc, r, _, g = to_rational_coeffs(p) >>> lc, r (7 + 5*sqrt(2), -2*sqrt(2) + 2) >>> g Poly(x**3 + x**2 - 1/4*x - 1/4, x, domain='QQ') >>> r1 = simplify(1/r) >>> Poly(lc*r**3*(g.as_expr()).subs({x:x*r1}), x, domain='EX') == p True """ from sympy.simplify.simplify import simplify def _try_rescale(f): """ try rescaling ``x -> alpha*x`` to convert f to a polynomial with rational coefficients. Returns ``alpha, f``; if the rescaling is successful, ``alpha`` is the rescaling factor, and ``f`` is the rescaled polynomial; else ``alpha`` is ``None``. """ from sympy.core.add import Add if not len(f.gens) == 1 or not (f.gens[0]).is_Atom: return None, f n = f.degree() lc = f.LC() coeffs = f.monic().all_coeffs()[1:] coeffs = [simplify(coeffx) for coeffx in coeffs] if coeffs[-2] and not all(coeffx.is_rational for coeffx in coeffs): rescale1_x = simplify(coeffs[-2]/coeffs[-1]) coeffs1 = [] for i in range(len(coeffs)): coeffx = simplify(coeffs[i]*rescale1_x**(i + 1)) if not coeffx.is_rational: break coeffs1.append(coeffx) else: rescale_x = simplify(1/rescale1_x) x = f.gens[0] v = [x**n] for i in range(1, n + 1): v.append(coeffs1[i - 1]*x**(n - i)) f = Add(*v) f = Poly(f) return lc, rescale_x, f return None def _try_translate(f): """ try translating ``x -> x + alpha`` to convert f to a polynomial with rational coefficients. Returns ``alpha, f``; if the translating is successful, ``alpha`` is the translating factor, and ``f`` is the shifted polynomial; else ``alpha`` is ``None``. """ from sympy.core.add import Add if not len(f.gens) == 1 or not (f.gens[0]).is_Atom: return None, f n = f.degree() f1 = f.monic() coeffs = f1.all_coeffs()[1:] c = simplify(coeffs[0]) if c and not c.is_rational: func = Add if c.is_Add: args = c.args func = c.func else: args = [c] sifted = sift(args, lambda z: z.is_rational) c1, c2 = sifted[True], sifted[False] alpha = -func(*c2)/n f2 = f1.shift(alpha) return alpha, f2 return None def _has_square_roots(p): """ Return True if ``f`` is a sum with square roots but no other root """ from sympy.core.exprtools import Factors coeffs = p.coeffs() has_sq = False for y in coeffs: for x in Add.make_args(y): f = Factors(x).factors r = [wx.q for wx in f.values() if wx.is_Rational and wx.q >= 2] if not r: continue if min(r) == 2: has_sq = True if max(r) > 2: return False return has_sq if f.get_domain().is_EX and _has_square_roots(f): r = _try_rescale(f) if r: return r[0], r[1], None, r[2] else: r = _try_translate(f) if r: return None, None, r[0], r[1] return None def _torational_factor_list(p, x): """ helper function to factor polynomial using to_rational_coeffs Examples ======== >>> from sympy.polys.polytools import _torational_factor_list >>> from sympy.abc import x >>> from sympy import sqrt, expand, Mul >>> p = expand(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))})) >>> factors = _torational_factor_list(p, x); factors (-2, [(-x*(1 + sqrt(2))/2 + 1, 1), (-x*(1 + sqrt(2)) - 1, 1), (-x*(1 + sqrt(2)) + 1, 1)]) >>> expand(factors[0]*Mul(*[z[0] for z in factors[1]])) == p True >>> p = expand(((x**2-1)*(x-2)).subs({x:x + sqrt(2)})) >>> factors = _torational_factor_list(p, x); factors (1, [(x - 2 + sqrt(2), 1), (x - 1 + sqrt(2), 1), (x + 1 + sqrt(2), 1)]) >>> expand(factors[0]*Mul(*[z[0] for z in factors[1]])) == p True """ from sympy.simplify.simplify import simplify p1 = Poly(p, x, domain='EX') n = p1.degree() res = to_rational_coeffs(p1) if not res: return None lc, r, t, g = res factors = factor_list(g.as_expr()) if lc: c = simplify(factors[0]*lc*r**n) r1 = simplify(1/r) a = [] for z in factors[1:][0]: a.append((simplify(z[0].subs({x: x*r1})), z[1])) else: c = factors[0] a = [] for z in factors[1:][0]: a.append((z[0].subs({x: x - t}), z[1])) return (c, a) @public def sqf_list(f, *gens, **args): """ Compute a list of square-free factors of ``f``. Examples ======== >>> from sympy import sqf_list >>> from sympy.abc import x >>> sqf_list(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) (2, [(x + 1, 2), (x + 2, 3)]) """ return _generic_factor_list(f, gens, args, method='sqf') @public def sqf(f, *gens, **args): """ Compute square-free factorization of ``f``. Examples ======== >>> from sympy import sqf >>> from sympy.abc import x >>> sqf(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) 2*(x + 1)**2*(x + 2)**3 """ return _generic_factor(f, gens, args, method='sqf') @public def factor_list(f, *gens, **args): """ Compute a list of irreducible factors of ``f``. Examples ======== >>> from sympy import factor_list >>> from sympy.abc import x, y >>> factor_list(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) (2, [(x + y, 1), (x**2 + 1, 2)]) """ return _generic_factor_list(f, gens, args, method='factor') @public def factor(f, *gens, **args): """ Compute the factorization of expression, ``f``, into irreducibles. (To factor an integer into primes, use ``factorint``.) There two modes implemented: symbolic and formal. If ``f`` is not an instance of :class:`Poly` and generators are not specified, then the former mode is used. Otherwise, the formal mode is used. In symbolic mode, :func:`factor` will traverse the expression tree and factor its components without any prior expansion, unless an instance of :class:`Add` is encountered (in this case formal factorization is used). This way :func:`factor` can handle large or symbolic exponents. By default, the factorization is computed over the rationals. To factor over other domain, e.g. an algebraic or finite field, use appropriate options: ``extension``, ``modulus`` or ``domain``. Examples ======== >>> from sympy import factor, sqrt >>> from sympy.abc import x, y >>> factor(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) 2*(x + y)*(x**2 + 1)**2 >>> factor(x**2 + 1) x**2 + 1 >>> factor(x**2 + 1, modulus=2) (x + 1)**2 >>> factor(x**2 + 1, gaussian=True) (x - I)*(x + I) >>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2)) >>> factor((x**2 - 1)/(x**2 + 4*x + 4)) (x - 1)*(x + 1)/(x + 2)**2 >>> factor((x**2 + 4*x + 4)**10000000*(x**2 + 1)) (x + 2)**20000000*(x**2 + 1) By default, factor deals with an expression as a whole: >>> eq = 2**(x**2 + 2*x + 1) >>> factor(eq) 2**(x**2 + 2*x + 1) If the ``deep`` flag is True then subexpressions will be factored: >>> factor(eq, deep=True) 2**((x + 1)**2) See Also ======== sympy.ntheory.factor_.factorint """ f = sympify(f) if args.pop('deep', False): partials = {} muladd = f.atoms(Mul, Add) for p in muladd: fac = factor(p, *gens, **args) if (fac.is_Mul or fac.is_Pow) and fac != p: partials[p] = fac return f.xreplace(partials) try: return _generic_factor(f, gens, args, method='factor') except PolynomialError as msg: if not f.is_commutative: from sympy.core.exprtools import factor_nc return factor_nc(f) else: raise PolynomialError(msg) @public def intervals(F, all=False, eps=None, inf=None, sup=None, strict=False, fast=False, sqf=False): """ Compute isolating intervals for roots of ``f``. Examples ======== >>> from sympy import intervals >>> from sympy.abc import x >>> intervals(x**2 - 3) [((-2, -1), 1), ((1, 2), 1)] >>> intervals(x**2 - 3, eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] """ if not hasattr(F, '__iter__'): try: F = Poly(F) except GeneratorsNeeded: return [] return F.intervals(all=all, eps=eps, inf=inf, sup=sup, fast=fast, sqf=sqf) else: polys, opt = parallel_poly_from_expr(F, domain='QQ') if len(opt.gens) > 1: raise MultivariatePolynomialError for i, poly in enumerate(polys): polys[i] = poly.rep.rep if eps is not None: eps = opt.domain.convert(eps) if eps <= 0: raise ValueError("'eps' must be a positive rational") if inf is not None: inf = opt.domain.convert(inf) if sup is not None: sup = opt.domain.convert(sup) intervals = dup_isolate_real_roots_list(polys, opt.domain, eps=eps, inf=inf, sup=sup, strict=strict, fast=fast) result = [] for (s, t), indices in intervals: s, t = opt.domain.to_sympy(s), opt.domain.to_sympy(t) result.append(((s, t), indices)) return result @public def refine_root(f, s, t, eps=None, steps=None, fast=False, check_sqf=False): """ Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import refine_root >>> from sympy.abc import x >>> refine_root(x**2 - 3, 1, 2, eps=1e-2) (19/11, 26/15) """ try: F = Poly(f) except GeneratorsNeeded: raise PolynomialError( "can't refine a root of %s, not a polynomial" % f) return F.refine_root(s, t, eps=eps, steps=steps, fast=fast, check_sqf=check_sqf) @public def count_roots(f, inf=None, sup=None): """ Return the number of roots of ``f`` in ``[inf, sup]`` interval. If one of ``inf`` or ``sup`` is complex, it will return the number of roots in the complex rectangle with corners at ``inf`` and ``sup``. Examples ======== >>> from sympy import count_roots, I >>> from sympy.abc import x >>> count_roots(x**4 - 4, -3, 3) 2 >>> count_roots(x**4 - 4, 0, 1 + 3*I) 1 """ try: F = Poly(f, greedy=False) except GeneratorsNeeded: raise PolynomialError("can't count roots of %s, not a polynomial" % f) return F.count_roots(inf=inf, sup=sup) @public def real_roots(f, multiple=True): """ Return a list of real roots with multiplicities of ``f``. Examples ======== >>> from sympy import real_roots >>> from sympy.abc import x >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4) [-1/2, 2, 2] """ try: F = Poly(f, greedy=False) except GeneratorsNeeded: raise PolynomialError( "can't compute real roots of %s, not a polynomial" % f) return F.real_roots(multiple=multiple) @public def nroots(f, n=15, maxsteps=50, cleanup=True): """ Compute numerical approximations of roots of ``f``. Examples ======== >>> from sympy import nroots >>> from sympy.abc import x >>> nroots(x**2 - 3, n=15) [-1.73205080756888, 1.73205080756888] >>> nroots(x**2 - 3, n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] """ try: F = Poly(f, greedy=False) except GeneratorsNeeded: raise PolynomialError( "can't compute numerical roots of %s, not a polynomial" % f) return F.nroots(n=n, maxsteps=maxsteps, cleanup=cleanup) @public def ground_roots(f, *gens, **args): """ Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import ground_roots >>> from sympy.abc import x >>> ground_roots(x**6 - 4*x**4 + 4*x**3 - x**2) {0: 2, 1: 2} """ options.allowed_flags(args, []) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('ground_roots', 1, exc) return F.ground_roots() @public def nth_power_roots_poly(f, n, *gens, **args): """ Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import nth_power_roots_poly, factor, roots >>> from sympy.abc import x >>> f = x**4 - x**2 + 1 >>> g = factor(nth_power_roots_poly(f, 2)) >>> g (x**2 - x + 1)**2 >>> R_f = [ (r**2).expand() for r in roots(f) ] >>> R_g = roots(g).keys() >>> set(R_f) == set(R_g) True """ options.allowed_flags(args, []) try: F, opt = poly_from_expr(f, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('nth_power_roots_poly', 1, exc) result = F.nth_power_roots_poly(n) if not opt.polys: return result.as_expr() else: return result @public def cancel(f, *gens, **args): """ Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol >>> from sympy.abc import x >>> A = Symbol('A', commutative=False) >>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2 """ from sympy.core.exprtools import factor_terms options.allowed_flags(args, ['polys']) f = sympify(f) if not isinstance(f, (tuple, Tuple)): if f.is_Number or isinstance(f, Relational) or not isinstance(f, Expr): return f f = factor_terms(f, radical=True) p, q = f.as_numer_denom() elif len(f) == 2: p, q = f elif isinstance(f, Tuple): return factor_terms(f) else: raise ValueError('unexpected argument: %s' % f) try: (F, G), opt = parallel_poly_from_expr((p, q), *gens, **args) except PolificationFailed: if not isinstance(f, (tuple, Tuple)): return f else: return S.One, p, q except PolynomialError as msg: if f.is_commutative and not f.has(Piecewise): raise PolynomialError(msg) # Handling of noncommutative and/or piecewise expressions if f.is_Add or f.is_Mul: sifted = sift(f.args, lambda x: x.is_commutative and not x.has(Piecewise)) c, nc = sifted[True], sifted[False] nc = [cancel(i) for i in nc] return f.func(cancel(f.func._from_args(c)), *nc) else: reps = [] pot = preorder_traversal(f) next(pot) for e in pot: # XXX: This should really skip anything that's not Expr. if isinstance(e, (tuple, Tuple, BooleanAtom)): continue try: reps.append((e, cancel(e))) pot.skip() # this was handled successfully except NotImplementedError: pass return f.xreplace(dict(reps)) c, P, Q = F.cancel(G) if not isinstance(f, (tuple, Tuple)): return c*(P.as_expr()/Q.as_expr()) else: if not opt.polys: return c, P.as_expr(), Q.as_expr() else: return c, P, Q @public def reduced(f, G, *gens, **args): """ Reduces a polynomial ``f`` modulo a set of polynomials ``G``. Given a polynomial ``f`` and a set of polynomials ``G = (g_1, ..., g_n)``, computes a set of quotients ``q = (q_1, ..., q_n)`` and the remainder ``r`` such that ``f = q_1*g_1 + ... + q_n*g_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> from sympy import reduced >>> from sympy.abc import x, y >>> reduced(2*x**4 + y**2 - x**2 + y**3, [x**3 - x, y**3 - y]) ([2*x, 1], x**2 + y**2 + y) """ options.allowed_flags(args, ['polys', 'auto']) try: polys, opt = parallel_poly_from_expr([f] + list(G), *gens, **args) except PolificationFailed as exc: raise ComputationFailed('reduced', 0, exc) domain = opt.domain retract = False if opt.auto and domain.has_Ring and not domain.has_Field: opt = opt.clone(dict(domain=domain.get_field())) retract = True from sympy.polys.rings import xring _ring, _ = xring(opt.gens, opt.domain, opt.order) for i, poly in enumerate(polys): poly = poly.set_domain(opt.domain).rep.to_dict() polys[i] = _ring.from_dict(poly) Q, r = polys[0].div(polys[1:]) Q = [Poly._from_dict(dict(q), opt) for q in Q] r = Poly._from_dict(dict(r), opt) if retract: try: _Q, _r = [q.to_ring() for q in Q], r.to_ring() except CoercionFailed: pass else: Q, r = _Q, _r if not opt.polys: return [q.as_expr() for q in Q], r.as_expr() else: return Q, r @public def groebner(F, *gens, **args): """ Computes the reduced Groebner basis for a set of polynomials. Use the ``order`` argument to set the monomial ordering that will be used to compute the basis. Allowed orders are ``lex``, ``grlex`` and ``grevlex``. If no order is specified, it defaults to ``lex``. For more information on Groebner bases, see the references and the docstring of `solve_poly_system()`. Examples ======== Example taken from [1]. >>> from sympy import groebner >>> from sympy.abc import x, y >>> F = [x*y - 2*y, 2*y**2 - x**2] >>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex') By default, an improved implementation of the Buchberger algorithm is used. Optionally, an implementation of the F5B algorithm can be used. The algorithm can be set using ``method`` flag or with the :func:`setup` function from :mod:`sympy.polys.polyconfig`: >>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)] >>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') References ========== 1. [Buchberger01]_ 2. [Cox97]_ """ return GroebnerBasis(F, *gens, **args) @public def is_zero_dimensional(F, *gens, **args): """ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 """ return GroebnerBasis(F, *gens, **args).is_zero_dimensional @public class GroebnerBasis(Basic): """Represents a reduced Groebner basis. """ def __new__(cls, F, *gens, **args): """Compute a reduced Groebner basis for a system of polynomials. """ options.allowed_flags(args, ['polys', 'method']) try: polys, opt = parallel_poly_from_expr(F, *gens, **args) except PolificationFailed as exc: raise ComputationFailed('groebner', len(F), exc) from sympy.polys.rings import PolyRing ring = PolyRing(opt.gens, opt.domain, opt.order) for i, poly in enumerate(polys): polys[i] = ring.from_dict(poly.rep.to_dict()) G = _groebner(polys, ring, method=opt.method) G = [Poly._from_dict(g, opt) for g in G] return cls._new(G, opt) @classmethod def _new(cls, basis, options): obj = Basic.__new__(cls) obj._basis = tuple(basis) obj._options = options return obj @property def args(self): return (Tuple(*self._basis), Tuple(*self._options.gens)) @property def exprs(self): return [poly.as_expr() for poly in self._basis] @property def polys(self): return list(self._basis) @property def gens(self): return self._options.gens @property def domain(self): return self._options.domain @property def order(self): return self._options.order def __len__(self): return len(self._basis) def __iter__(self): if self._options.polys: return iter(self.polys) else: return iter(self.exprs) def __getitem__(self, item): if self._options.polys: basis = self.polys else: basis = self.exprs return basis[item] def __hash__(self): return hash((self._basis, tuple(self._options.items()))) def __eq__(self, other): if isinstance(other, self.__class__): return self._basis == other._basis and self._options == other._options elif iterable(other): return self.polys == list(other) or self.exprs == list(other) else: return False def __ne__(self, other): return not self.__eq__(other) @property def is_zero_dimensional(self): """ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 """ def single_var(monomial): return sum(map(bool, monomial)) == 1 exponents = Monomial([0]*len(self.gens)) order = self._options.order for poly in self.polys: monomial = poly.LM(order=order) if single_var(monomial): exponents *= monomial # If any element of the exponents vector is zero, then there's # a variable for which there's no degree bound and the ideal # generated by this Groebner basis isn't zero-dimensional. return all(exponents) def fglm(self, order): """ Convert a Groebner basis from one ordering to another. The FGLM algorithm converts reduced Groebner bases of zero-dimensional ideals from one ordering to another. This method is often used when it is infeasible to compute a Groebner basis with respect to a particular ordering directly. Examples ======== >>> from sympy.abc import x, y >>> from sympy import groebner >>> F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1] >>> G = groebner(F, x, y, order='grlex') >>> list(G.fglm('lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] >>> list(groebner(F, x, y, order='lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] References ========== J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient Computation of Zero-dimensional Groebner Bases by Change of Ordering """ opt = self._options src_order = opt.order dst_order = monomial_key(order) if src_order == dst_order: return self if not self.is_zero_dimensional: raise NotImplementedError("can't convert Groebner bases of ideals with positive dimension") polys = list(self._basis) domain = opt.domain opt = opt.clone(dict( domain=domain.get_field(), order=dst_order, )) from sympy.polys.rings import xring _ring, _ = xring(opt.gens, opt.domain, src_order) for i, poly in enumerate(polys): poly = poly.set_domain(opt.domain).rep.to_dict() polys[i] = _ring.from_dict(poly) G = matrix_fglm(polys, _ring, dst_order) G = [Poly._from_dict(dict(g), opt) for g in G] if not domain.has_Field: G = [g.clear_denoms(convert=True)[1] for g in G] opt.domain = domain return self._new(G, opt) def reduce(self, expr, auto=True): """ Reduces a polynomial modulo a Groebner basis. Given a polynomial ``f`` and a set of polynomials ``G = (g_1, ..., g_n)``, computes a set of quotients ``q = (q_1, ..., q_n)`` and the remainder ``r`` such that ``f = q_1*f_1 + ... + q_n*f_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> from sympy import groebner, expand >>> from sympy.abc import x, y >>> f = 2*x**4 - x**2 + y**3 + y**2 >>> G = groebner([x**3 - x, y**3 - y]) >>> G.reduce(f) ([2*x, 1], x**2 + y**2 + y) >>> Q, r = _ >>> expand(sum(q*g for q, g in zip(Q, G)) + r) 2*x**4 - x**2 + y**3 + y**2 >>> _ == f True """ poly = Poly._from_expr(expr, self._options) polys = [poly] + list(self._basis) opt = self._options domain = opt.domain retract = False if auto and domain.has_Ring and not domain.has_Field: opt = opt.clone(dict(domain=domain.get_field())) retract = True from sympy.polys.rings import xring _ring, _ = xring(opt.gens, opt.domain, opt.order) for i, poly in enumerate(polys): poly = poly.set_domain(opt.domain).rep.to_dict() polys[i] = _ring.from_dict(poly) Q, r = polys[0].div(polys[1:]) Q = [Poly._from_dict(dict(q), opt) for q in Q] r = Poly._from_dict(dict(r), opt) if retract: try: _Q, _r = [q.to_ring() for q in Q], r.to_ring() except CoercionFailed: pass else: Q, r = _Q, _r if not opt.polys: return [q.as_expr() for q in Q], r.as_expr() else: return Q, r def contains(self, poly): """ Check if ``poly`` belongs the ideal generated by ``self``. Examples ======== >>> from sympy import groebner >>> from sympy.abc import x, y >>> f = 2*x**3 + y**3 + 3*y >>> G = groebner([x**2 + y**2 - 1, x*y - 2]) >>> G.contains(f) True >>> G.contains(f + 1) False """ return self.reduce(poly)[1] == 0 @public def poly(expr, *gens, **args): """ Efficiently transform an expression into a polynomial. Examples ======== >>> from sympy import poly >>> from sympy.abc import x >>> poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ') """ options.allowed_flags(args, []) def _poly(expr, opt): terms, poly_terms = [], [] for term in Add.make_args(expr): factors, poly_factors = [], [] for factor in Mul.make_args(term): if factor.is_Add: poly_factors.append(_poly(factor, opt)) elif factor.is_Pow and factor.base.is_Add and factor.exp.is_Integer: poly_factors.append( _poly(factor.base, opt).pow(factor.exp)) else: factors.append(factor) if not poly_factors: terms.append(term) else: product = poly_factors[0] for factor in poly_factors[1:]: product = product.mul(factor) if factors: factor = Mul(*factors) if factor.is_Number: product = product.mul(factor) else: product = product.mul(Poly._from_expr(factor, opt)) poly_terms.append(product) if not poly_terms: result = Poly._from_expr(expr, opt) else: result = poly_terms[0] for term in poly_terms[1:]: result = result.add(term) if terms: term = Add(*terms) if term.is_Number: result = result.add(term) else: result = result.add(Poly._from_expr(term, opt)) return result.reorder(*opt.get('gens', ()), **args) expr = sympify(expr) if expr.is_Poly: return Poly(expr, *gens, **args) if 'expand' not in args: args['expand'] = False opt = options.build_options(gens, args) return _poly(expr, opt) from sympy.functions import Piecewise
wolfram74/numerical_methods_iserles_notes
venv/lib/python2.7/site-packages/sympy/polys/polytools.py
Python
mit
171,109
0.000316
from .assembler import IndexCardAssembler
johnbachman/indra
indra/assemblers/index_card/__init__.py
Python
bsd-2-clause
42
0
# vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2014 Violin Memory, Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """ Violin Memory 6000 Series All-Flash Array Common Driver for Openstack Cinder Uses Violin REST API via XG-Tools to manage a standard V6000 series flash array to provide network block-storage services. by Ryan Lucio Senior Software Engineer Violin Memory """ import re import time from oslo.config import cfg from cinder import context from cinder import exception from cinder.openstack.common import log as logging from cinder import utils from cinder.volume.drivers.san import san from cinder.volume import volume_types LOG = logging.getLogger(__name__) # support vmos versions V6.3.0.4 or newer # support vmos versions V6.3.1 or newer VMOS_SUPPORTED_VERSION_PATTERNS = ['V6.3.0.[4-9]', 'V6.3.[1-9].?[0-9]?'] try: import vxg except ImportError: LOG.exception( _("The Violin V6000 driver for Cinder requires the presence of " "the Violin 'XG-Tools', python libraries for facilitating " "communication between applications and the v6000 XML API. " "The libraries can be downloaded from the Violin Memory " "support website at http://www.violin-memory.com/support")) raise else: LOG.info(_("Running with xg-tools version: %s"), vxg.__version__) violin_opts = [ cfg.StrOpt('gateway_vip', default='', help='IP address or hostname of the v6000 master VIP'), cfg.StrOpt('gateway_mga', default='', help='IP address or hostname of mg-a'), cfg.StrOpt('gateway_mgb', default='', help='IP address or hostname of mg-b'), cfg.StrOpt('gateway_user', default='admin', help='User name for connecting to the Memory Gateway'), cfg.StrOpt('gateway_password', default='', help='User name for connecting to the Memory Gateway', secret=True), cfg.BoolOpt('use_igroups', default=False, help='Use igroups to manage targets and initiators'), cfg.BoolOpt('use_thin_luns', default=False, help='Use thin luns instead of thick luns'), ] CONF = cfg.CONF CONF.register_opts(violin_opts) class InvalidBackendConfig(exception.CinderException): message = _("Volume backend config is invalid: %(reason)s") class RequestRetryTimeout(exception.CinderException): message = _("Backend service retry timeout hit: %(timeout)s sec") class ViolinBackendErr(exception.CinderException): message = _("Backend reports: %(message)s") class ViolinBackendErrExists(exception.CinderException): message = _("Backend reports: item already exists") class ViolinBackendErrNotFound(exception.CinderException): message = _("Backend reports: item not found") class V6000CommonDriver(san.SanDriver): """Executes commands relating to Violin Memory Arrays.""" def __init__(self, *args, **kwargs): super(V6000CommonDriver, self).__init__(*args, **kwargs) self.request_timeout = 300 self.vmem_vip = None self.vmem_mga = None self.vmem_mgb = None self.container = "" self.stats = {} self.config = kwargs.get('configuration', None) self.context = None self.lun_tracker = LunIdList(self.db) if self.config: self.config.append_config_values(violin_opts) def do_setup(self, context): """Any initialization the driver does while starting.""" if not self.config.gateway_vip: raise exception.InvalidInput( reason=_('Gateway VIP is not set')) if not self.config.gateway_mga: raise exception.InvalidInput( reason=_('Gateway IP for mg-a is not set')) if not self.config.gateway_mgb: raise exception.InvalidInput( reason=_('Gateway IP for mg-b is not set')) self.vmem_vip = vxg.open(self.config.gateway_vip, self.config.gateway_user, self.config.gateway_password, keepalive=True) self.vmem_mga = vxg.open(self.config.gateway_mga, self.config.gateway_user, self.config.gateway_password, keepalive=True) self.vmem_mgb = vxg.open(self.config.gateway_mgb, self.config.gateway_user, self.config.gateway_password, keepalive=True) self.context = context vip = self.vmem_vip.basic ret_dict = vip.get_node_values("/vshare/state/local/container/*") if ret_dict: self.container = ret_dict.items()[0][1] ret_dict = vip.get_node_values( "/vshare/state/local/container/%s/lun/*" % self.container) if ret_dict: self.lun_tracker.update_from_volume_ids(ret_dict.values()) ret_dict = vip.get_node_values( "/vshare/state/snapshot/container/%s/lun/*" % self.container) if ret_dict: for vol_id in ret_dict.values(): snaps = vip.get_node_values( "/vshare/state/snapshot/container/%s/lun/%s/snap/*" % (self.container, vol_id)) self.lun_tracker.update_from_snapshot_ids(snaps.values()) def check_for_setup_error(self): """Returns an error if prerequisites aren't met.""" vip = self.vmem_vip.basic if len(self.container) == 0: raise InvalidBackendConfig(reason=_('container is missing')) if not self._is_supported_vmos_version(self.vmem_vip.version): msg = _('VMOS version is not supported') raise InvalidBackendConfig(reason=msg) bn1 = ("/vshare/state/local/container/%s/threshold/usedspace" "/threshold_hard_val" % self.container) bn2 = ("/vshare/state/local/container/%s/threshold/provision" "/threshold_hard_val" % self.container) ret_dict = vip.get_node_values([bn1, bn2]) for node in ret_dict: # The infrastructure does not support space reclamation so # ensure it is disabled. When used space exceeds the hard # limit, snapshot space reclamation begins. Default is 0 # => no space reclamation. # if node.endswith('/usedspace/threshold_hard_val'): if ret_dict[node] != 0: msg = _('space reclamation threshold is enabled') raise InvalidBackendConfig(reason=msg) # The infrastructure does not support overprovisioning so # ensure it is disabled. When provisioned space exceeds # the hard limit, further provisioning is stopped. # Default is 100 => provisioned space equals usable space. # elif node.endswith('/provision/threshold_hard_val'): if ret_dict[node] != 100: msg = _('provisioned space threshold not equal to ' 'usable space') raise InvalidBackendConfig(reason=msg) def create_volume(self, volume): """Creates a volume.""" self._create_lun(volume) def delete_volume(self, volume): """Deletes a volume.""" self._delete_lun(volume) def create_snapshot(self, snapshot): """Creates a snapshot from an existing volume.""" self._create_lun_snapshot(snapshot) def delete_snapshot(self, snapshot): """Deletes a snapshot.""" self._delete_lun_snapshot(snapshot) def create_volume_from_snapshot(self, volume, snapshot): """Creates a volume from a snapshot.""" snapshot['size'] = snapshot['volume']['size'] self._create_lun(volume) self.copy_volume_data(self.context, snapshot, volume) def create_cloned_volume(self, volume, src_vref): """Creates a full clone of the specified volume.""" self._create_lun(volume) self.copy_volume_data(self.context, src_vref, volume) def extend_volume(self, volume, new_size): """Extend an existing volume's size. The equivalent CLI command is "lun resize container <container_name> name <lun_name> size <gb>" Arguments: volume -- volume object provided by the Manager new_size -- new (increased) size in GB to be applied """ v = self.vmem_vip LOG.info(_("Extending lun %(id)s, from %(size)s to %(new_size)s GB") % {'id': volume['id'], 'size': volume['size'], 'new_size': new_size}) try: self._send_cmd(v.lun.resize_lun, 'Success', self.container, volume['id'], new_size) except Exception: LOG.exception(_("LUN extend failed!")) raise @utils.synchronized('vmem-lun') def _create_lun(self, volume): """Creates a new lun. The equivalent CLI command is "lun create container <container_name> name <lun_name> size <gb>" Arguments: volume -- volume object provided by the Manager """ lun_type = '0' v = self.vmem_vip LOG.info(_("Creating lun %(name)s, %(size)s GB") % volume) if self.config.use_thin_luns: lun_type = '1' # using the defaults for fields: quantity, nozero, # readonly, startnum, blksize, naca, alua, preferredport # try: self._send_cmd(v.lun.create_lun, 'LUN create: success!', self.container, volume['id'], volume['size'], 1, '0', lun_type, 'w', 1, 512, False, False, None) except ViolinBackendErrExists: LOG.info(_("Lun %s already exists, continuing"), volume['id']) except Exception: LOG.warn(_("Lun create failed!")) raise @utils.synchronized('vmem-lun') def _delete_lun(self, volume): """Deletes a lun. The equivalent CLI command is "no lun create container <container_name> name <lun_name>" Arguments: volume -- volume object provided by the Manager """ v = self.vmem_vip success_msgs = ['lun deletion started', ''] LOG.info(_("Deleting lun %s"), volume['id']) try: self._send_cmd(v.lun.bulk_delete_luns, success_msgs, self.container, volume['id']) except ViolinBackendErrNotFound: LOG.info(_("Lun %s already deleted, continuing"), volume['id']) except ViolinBackendErrExists: LOG.warn(_("Lun %s has dependent snapshots, skipping"), volume['id']) raise exception.VolumeIsBusy(volume_name=volume['id']) except Exception: LOG.exception(_("Lun delete failed!")) raise self.lun_tracker.free_lun_id_for_volume(volume) @utils.synchronized('vmem-snap') def _create_lun_snapshot(self, snapshot): """Creates a new snapshot for a lun. The equivalent CLI command is "snapshot create container <container> lun <volume_name> name <snapshot_name>" Arguments: snapshot -- snapshot object provided by the Manager """ v = self.vmem_vip LOG.info(_("Creating snapshot %s"), snapshot['id']) try: self._send_cmd(v.snapshot.create_lun_snapshot, 'Snapshot create: success!', self.container, snapshot['volume_id'], snapshot['id']) except ViolinBackendErrExists: LOG.info(_("Snapshot %s already exists, continuing"), snapshot['id']) except Exception: LOG.exception(_("LUN snapshot create failed!")) raise @utils.synchronized('vmem-snap') def _delete_lun_snapshot(self, snapshot): """Deletes an existing snapshot for a lun. The equivalent CLI command is "no snapshot create container <container> lun <volume_name> name <snapshot_name>" Arguments: snapshot -- snapshot object provided by the Manager """ v = self.vmem_vip LOG.info(_("Deleting snapshot %s"), snapshot['id']) try: self._send_cmd(v.snapshot.delete_lun_snapshot, 'Snapshot delete: success!', self.container, snapshot['volume_id'], snapshot['id']) except ViolinBackendErrNotFound: LOG.info(_("Snapshot %s already deleted, continuing"), snapshot['id']) except Exception: LOG.exception(_("LUN snapshot delete failed!")) raise self.lun_tracker.free_lun_id_for_snapshot(snapshot) def _send_cmd(self, request_func, success_msgs, *args): """Run an XG request function, and retry until the request returns a success message, a failure message, or the global request timeout is hit. This wrapper is meant to deal with backend requests that can fail for any variety of reasons, for instance, when the system is already busy handling other LUN requests. It is also smart enough to give up if clustering is down (eg no HA available), there is no space left, or other "fatal" errors are returned (see _fatal_error_code() for a list of all known error conditions). Arguments: request_func -- XG api method to call success_msgs -- Success messages expected from the backend *args -- argument array to be passed to the request_func Returns: The response dict from the last XG call. """ resp = {} start = time.time() done = False if isinstance(success_msgs, basestring): success_msgs = [success_msgs] while not done: if time.time() - start >= self.request_timeout: raise RequestRetryTimeout(timeout=self.request_timeout) resp = request_func(*args) if not resp['message']: # XG requests will return None for a message if no message # string is passed int the raw response resp['message'] = '' for msg in success_msgs: if not resp['code'] and msg in resp['message']: done = True break self._fatal_error_code(resp) return resp def _send_cmd_and_verify(self, request_func, verify_func, request_success_msgs='', rargs=[], vargs=[]): """Run an XG request function, and verify success using an additional verify function. If the verification fails, then retry the request/verify cycle until both functions are successful, the request function returns a failure message, or the global request timeout is hit. This wrapper is meant to deal with backend requests that can fail for any variety of reasons, for instance, when the system is already busy handling other LUN requests. It is also smart enough to give up if clustering is down (eg no HA available), there is no space left, or other "fatal" errors are returned (see _fatal_error_code() for a list of all known error conditions). Arguments: request_func -- XG api method to call verify_func -- function to call to verify request was completed successfully (eg for export) request_success_msg -- Success message expected from the backend for the request_func *rargs -- argument array to be passed to the request_func *vargs -- argument array to be passed to the verify_func Returns: The response dict from the last XG call. """ resp = {} start = time.time() request_needed = True verify_needed = True if isinstance(request_success_msgs, basestring): request_success_msgs = [request_success_msgs] while request_needed or verify_needed: if time.time() - start >= self.request_timeout: raise RequestRetryTimeout(timeout=self.request_timeout) if request_needed: resp = request_func(*rargs) if not resp['message']: # XG requests will return None for a message if no message # string is passed int the raw response resp['message'] = '' for msg in request_success_msgs: if not resp['code'] and msg in resp['message']: # XG request func was completed request_needed = False break self._fatal_error_code(resp) elif verify_needed: success = verify_func(*vargs) if success: # XG verify func was completed verify_needed = False else: # try sending the request again request_needed = True return resp def _get_igroup(self, volume, connector): """Gets the igroup that should be used when configuring a volume. Arguments: volume -- volume object used to determine the igroup name Returns: igroup_name -- name of igroup (for configuring targets & initiators) """ v = self.vmem_vip # Use the connector's primary hostname and use that as the # name of the igroup. The name must follow syntax rules # required by the array: "must contain only alphanumeric # characters, dashes, and underscores. The first character # must be alphanumeric". # igroup_name = re.sub(r'[\W]', '_', connector['host']) # verify that the igroup has been created on the backend, and # if it doesn't exist, create it! # bn = "/vshare/config/igroup/%s" % igroup_name resp = v.basic.get_node_values(bn) if not len(resp): v.igroup.create_igroup(igroup_name) return igroup_name def _get_volume_type_extra_spec(self, volume, spec_key): """Parse data stored in a volume_type's extra_specs table. Code adapted from examples in cinder/volume/drivers/solidfire.py and cinder/openstack/common/scheduler/filters/capabilities_filter.py. Arguments: volume -- volume object containing volume_type to query spec_key -- the metadata key to search for Returns: spec_value -- string value associated with spec_key """ spec_value = None ctxt = context.get_admin_context() typeid = volume['volume_type_id'] if typeid: volume_type = volume_types.get_volume_type(ctxt, typeid) volume_specs = volume_type.get('extra_specs') for key, val in volume_specs.iteritems(): # Havana release altered extra_specs to require a # prefix on all non-host-capability related extra # specs, so that prefix is stripped here before # checking the key. # if ':' in key: scope = key.split(':') key = scope[1] if key == spec_key: spec_value = val break return spec_value def _wait_for_exportstate(self, volume_name, state=False): """Polls backend to verify volume's export configuration. XG sets/queries following a request to create or delete a lun export may fail on the backend if vshared is still processing the export action (or times out). We can check whether it is done by polling the export binding for a lun to ensure it is created or deleted. This function will try to verify the creation or removal of export state on both gateway nodes of the array every 5 seconds for up to 30 seconds. Arguments: volume_name -- name of volume to be polled state -- True to poll for existence, False for lack of Returns: True if the export state was correctly added or removed (depending on 'state' param) """ status = [False, False] mg_conns = [self.vmem_mga.basic, self.vmem_mgb.basic] success = False bn = "/vshare/config/export/container/%s/lun/%s" \ % (self.container, volume_name) for i in xrange(6): for node_id in xrange(2): if not status[node_id]: resp = mg_conns[node_id].get_node_values(bn) if state and len(resp.keys()): status[node_id] = True elif (not state) and (not len(resp.keys())): status[node_id] = True if status[0] and status[1]: success = True break else: time.sleep(5) return success def _is_supported_vmos_version(self, version_string): """Check that the version of VMOS running on the gateways is valid for use with the OpenStack drivers.""" for pattern in VMOS_SUPPORTED_VERSION_PATTERNS: if re.match(pattern, version_string): LOG.debug("Verified VMOS version %s is supported" % version_string) return True return False def _fatal_error_code(self, response): """Check the error code in a XG response for a fatal error, and returns an appropriate exception. Error codes extracted from vdmd_mgmt.c. Arguments: response -- a response dict result from an XG request """ # known non-fatal response codes # retry_codes = {1024: 'lun deletion in progress, try again later', 14032: 'lc_err_lock_busy'} if response['code'] == 14000: # lc_generic_error raise ViolinBackendErr(message=response['message']) elif response['code'] == 14002: # lc_err_assertion_failed raise ViolinBackendErr(message=response['message']) elif response['code'] == 14004: # lc_err_not_found raise ViolinBackendErrNotFound() elif response['code'] == 14005: # lc_err_exists raise ViolinBackendErrExists() elif response['code'] == 14008: # lc_err_unexpected_arg raise ViolinBackendErr(message=response['message']) elif response['code'] == 14014: # lc_err_io_error raise ViolinBackendErr(message=response['message']) elif response['code'] == 14016: # lc_err_io_closed raise ViolinBackendErr(message=response['message']) elif response['code'] == 14017: # lc_err_io_timeout raise ViolinBackendErr(message=response['message']) elif response['code'] == 14021: # lc_err_unexpected_case raise ViolinBackendErr(message=response['message']) elif response['code'] == 14025: # lc_err_no_fs_space raise ViolinBackendErr(message=response['message']) elif response['code'] == 14035: # lc_err_range raise ViolinBackendErr(message=response['message']) elif response['code'] == 14036: # lc_err_invalid_param raise ViolinBackendErr(message=response['message']) elif response['code'] == 14121: # lc_err_cancelled_err raise ViolinBackendErr(message=response['message']) elif response['code'] == 512: # Not enough free space in container (vdmd bug) raise ViolinBackendErr(message=response['message']) elif response['code'] == 1 and 'LUN ID conflict' \ in response['message']: # lun id conflict while attempting to export raise ViolinBackendErr(message=response['message']) class LunIdList(object): """Tracks available lun_ids for use when exporting a new lun for the first time. After instantiating a new LunIdList object, it should be updated (basically quiescing volumes/snapshot lun ID allocation between the array and the corresponding Openstack DB metadata). After that, the object can be queried to capture the next 'available' lun ID for use with exporting a new volume or snapshot. Only when the volume/snapshot is deleted entirely, the lun ID should be freed. Lun IDs are montonically increasing up to a max value of 16k, after which the selection will loop around to lun ID 1 and will continue to increment until an available ID is found. """ def __init__(self, db, *args, **kwargs): self.max_lun_id = 16000 self.lun_id_list = [0] * self.max_lun_id self.lun_id_list[0] = 1 self.prev_index = 1 self.free_index = 1 self.context = context.get_admin_context() self.db = db def update_from_volume_ids(self, id_list=[]): """Walk a list of volumes collected that the array knows about and check for any saved lun_id metadata for each of those volumes to fully sync the list. Note that the metadata keys are stored as strings. Arguments: id_list -- array containing names of volumes that exist on the backend (volume 'names' are UUIDs if they were made via the VMEM driver API) """ for item in id_list: try: metadata = self.db.volume_metadata_get(self.context, item) except exception.VolumeNotFound: LOG.warn(_("No db state for lun %s, skipping lun_id update"), item) else: if metadata and 'lun_id' in metadata: index = int(metadata['lun_id']) self.lun_id_list[index] = 1 LOG.debug("Set lun_id=%d for volume_id=%s" % (index, item)) self.update_free_index(index) def update_from_snapshot_ids(self, id_list=[]): """Walk a list of snapshots collected that the array knows about and check for any saved lun_id metadata for each of those snapshots to fully sync the list. Note that the metadata keys are stored as strings. Arguments: id_list -- array containing names of snapshots that exist on the backend (snapshot 'names' are UUIDs if they were made via the VMEM driver API) """ for item in id_list: try: metadata = self.db.snapshot_metadata_get(self.context, item) except exception.SnapshotNotFound: LOG.warn(_("No db state for snap %s, skipping lun_id update"), item) else: if metadata and 'lun_id' in metadata: index = int(metadata['lun_id']) self.lun_id_list[index] = 1 LOG.debug("Set lun_id=%d for snapshot_id=%s" % (index, item)) self.update_free_index(index) def get_lun_id_for_volume(self, volume): """Allocate a free a lun ID to a volume and create a lun_id tag in the volume's metadata. Arguments: volume -- the volume object to allocate a lun_id to """ metadata = self.db.volume_metadata_get(self.context, volume['id']) if not metadata or 'lun_id' not in metadata: metadata = {} metadata['lun_id'] = self.get_next_lun_id_str() self.db.volume_metadata_update(self.context, volume['id'], metadata, False) LOG.debug("Assigned lun_id %s to volume %s" % (metadata['lun_id'], volume['id'])) return metadata['lun_id'] def get_lun_id_for_snapshot(self, snapshot): """Allocate a free a lun ID to a snapshot and create a lun_id tag in the snapshot's metadata. Arguments: snapshot -- the snapshot object to allocate a lun_id to """ metadata = self.db.snapshot_metadata_get(self.context, snapshot['id']) if not metadata or 'lun_id' not in metadata: metadata = {} metadata['lun_id'] = self.get_next_lun_id_str() self.db.snapshot_metadata_update(self.context, snapshot['id'], metadata, False) LOG.debug("Assigned lun_id %s to volume %s" % (metadata['lun_id'], snapshot['id'])) return metadata['lun_id'] def free_lun_id_for_volume(self, volume): """Remove the lun_id tag saved in the volume's metadata and free the lun ID in the internal tracking array. Arguments: volume -- the volume object with a lun ID to be free'd """ metadata = self.db.volume_metadata_get(self.context, volume['id']) if metadata and 'lun_id' in metadata: self.free_lun_id_str(metadata['lun_id']) def free_lun_id_for_snapshot(self, snapshot): """Remove the lun_id tag saved in the snapshot's metadata and free the lun ID in the internal tracking array. Arguments: snapshot -- the snapshot object with a lun ID to be free'd """ metadata = self.db.snapshot_metadata_get(self.context, snapshot['id']) if metadata and 'lun_id' in metadata: self.free_lun_id_str(metadata['lun_id']) def get_next_lun_id_str(self): """Mark the next available lun_id as allocated and return it to the caller. Returns: next_id -- the lun ID that being allocated to the caller """ next_id = self.free_index self.lun_id_list[next_id] = 1 self.update_free_index() return str(next_id) def free_lun_id_str(self, value_str): """Mark a lun_id as now available, as if the lun was de-allocated. Arguments: value_str -- lun ID to free (in string format) """ value = int(value_str) self.lun_id_list[value] = 0 self.update_free_index() def update_free_index(self, index=None): """Update the free index, monotonically increasing, and looping back to 1 after the max lun ID value is hit. Arguments: index -- assume that all values below this number may be already allocated, so start searching at that value if it is higher than the free_index """ i = 0 count = 0 max_size = len(self.lun_id_list) if index and index > self.free_index: i = index + 1 else: i = self.free_index # avoid possibility of indexError if i >= max_size: i = 1 while self.lun_id_list[i] == 1 and count < max_size: count += 1 i += 1 if i >= max_size: i = 1 self.free_index = i if count == max_size: raise exception.Error("Cannot find free lun_id, giving up!")
rlucio/cinder-violin-driver-icehouse
cinder/volume/drivers/violin/v6000_common.py
Python
apache-2.0
32,857
0.00003
#!/usr/bin/env python ''' Generate valid and invalid base58 address and private key test vectors. Usage: gen_base58_test_vectors.py valid 50 > ../../src/test/data/base58_keys_valid.json gen_base58_test_vectors.py invalid 50 > ../../src/test/data/base58_keys_invalid.json ''' # 2012 Wladimir J. van der Laan # Released under MIT License import os from itertools import islice from base58 import b58encode, b58decode, b58encode_chk, b58decode_chk, b58chars import random from binascii import b2a_hex # key types PUBKEY_ADDRESS = 41 SCRIPT_ADDRESS = 5 PUBKEY_ADDRESS_TEST = 111 SCRIPT_ADDRESS_TEST = 196 PRIVKEY = 176 PRIVKEY_TEST = 239 metadata_keys = ['isPrivkey', 'isTestnet', 'addrType', 'isCompressed'] # templates for valid sequences templates = [ # prefix, payload_size, suffix, metadata # None = N/A ((PUBKEY_ADDRESS,), 20, (), (False, False, 'pubkey', None)), ((SCRIPT_ADDRESS,), 20, (), (False, False, 'script', None)), ((PUBKEY_ADDRESS_TEST,), 20, (), (False, True, 'pubkey', None)), ((SCRIPT_ADDRESS_TEST,), 20, (), (False, True, 'script', None)), ((PRIVKEY,), 32, (), (True, False, None, False)), ((PRIVKEY,), 32, (1,), (True, False, None, True)), ((PRIVKEY_TEST,), 32, (), (True, True, None, False)), ((PRIVKEY_TEST,), 32, (1,), (True, True, None, True)) ] def is_valid(v): '''Check vector v for validity''' result = b58decode_chk(v) if result is None: return False valid = False for template in templates: prefix = str(bytearray(template[0])) suffix = str(bytearray(template[2])) if result.startswith(prefix) and result.endswith(suffix): if (len(result) - len(prefix) - len(suffix)) == template[1]: return True return False def gen_valid_vectors(): '''Generate valid test vectors''' while True: for template in templates: prefix = str(bytearray(template[0])) payload = os.urandom(template[1]) suffix = str(bytearray(template[2])) rv = b58encode_chk(prefix + payload + suffix) assert is_valid(rv) metadata = dict([(x,y) for (x,y) in zip(metadata_keys,template[3]) if y is not None]) yield (rv, b2a_hex(payload), metadata) def gen_invalid_vector(template, corrupt_prefix, randomize_payload_size, corrupt_suffix): '''Generate possibly invalid vector''' if corrupt_prefix: prefix = os.urandom(1) else: prefix = str(bytearray(template[0])) if randomize_payload_size: payload = os.urandom(max(int(random.expovariate(0.5)), 50)) else: payload = os.urandom(template[1]) if corrupt_suffix: suffix = os.urandom(len(template[2])) else: suffix = str(bytearray(template[2])) return b58encode_chk(prefix + payload + suffix) def randbool(p = 0.5): '''Return True with P(p)''' return random.random() < p def gen_invalid_vectors(): '''Generate invalid test vectors''' # start with some manual edge-cases yield "", yield "x", while True: # kinds of invalid vectors: # invalid prefix # invalid payload length # invalid (randomized) suffix (add random data) # corrupt checksum for template in templates: val = gen_invalid_vector(template, randbool(0.2), randbool(0.2), randbool(0.2)) if random.randint(0,10)<1: # line corruption if randbool(): # add random character to end val += random.choice(b58chars) else: # replace random character in the middle n = random.randint(0, len(val)) val = val[0:n] + random.choice(b58chars) + val[n+1:] if not is_valid(val): yield val, if __name__ == '__main__': import sys, json iters = {'valid':gen_valid_vectors, 'invalid':gen_invalid_vectors} try: uiter = iters[sys.argv[1]] except IndexError: uiter = gen_valid_vectors try: count = int(sys.argv[2]) except IndexError: count = 0 data = list(islice(uiter(), count)) json.dump(data, sys.stdout, sort_keys=True, indent=4) sys.stdout.write('\n')
InsuraCoinDev/insuracoin
contrib/testgen/gen_base58_test_vectors.py
Python
mit
4,344
0.006906
sWordInfo = ReadValue('WordInfo') if not sWordInfo: sWordInfo = ReadValue('DictionaryLookup') sWordInfo = IniFormDialogInput('Input', 'Word', sWordInfo) if not sWordInfo: Exit() WriteValue('WordInfo', sWordInfo) SayLine('Please wait') # sAddress = 'http://api.wordnik.com/api/word.json/' + sWordInfo + '/definitions' sAddress = 'http://api.wordnik.com/api-v2/word.json/' + sWordInfo + '/definitions' dData = {'api_key' : '582e51dde9940b44120020cf4c80f871af2430e98b76dd698'} sResponse = '' try: sResponse = WebRequestGetToString(sAddress, dData) except: SayLine('No information available!') d = JsToPyObject(sResponse) lDefinitions = d['definition'] sText = Pluralize('Definition', len(lDefinitions)) + ' of ' + sWordInfo + ' from wordnik.com\r\n\r\n' # for dDefinition in lDefinitions: sText += dDefinition['headword'] + (', ' + dDefinition['partOfSpeech'] if dDefinition.has_key('partOfSpeech') else '') + '\r\n' + dDefinition['defTxtSummary'] + ('\r\n' + dDefinition.get('defTxtExtended', '')).rstrip() + '\r\n\r\n' # for dDefinition in lDefinitions: sText += (dDefinition['partOfSpeech'] + '\r\n' if dDefinition.has_key('partOfSpeech') else '').lstrip() + dDefinition['defTxtSummary'] + ('\r\n' + dDefinition.get('defTxtExtended', '')).rstrip() + '\r\n\r\n' for dDefinition in lDefinitions: if dDefinition.has_key('partOfSpeech'): sText += dDefinition['partOfSpeech'] + '\r\n' if dDefinition.has_key('defTxtSummary'): sText += dDefinition['defTxtSummary'] + '\r\n' if dDefinition.has_key('defTxtExtended'): sText += dDefinition['defTxtExtended'] + '\r\n' sText += '\r\n' sDefinitions = sText.strip() # sAddress = 'http://api.wordnik.com/api/word.json/' + sWordInfo + '/examples' sAddress = 'http://api.wordnik.com/api-v2/word.json/' + sWordInfo + '/examples' dData = {'api_key' : '582e51dde9940b44120020cf4c80f871af2430e98b76dd698'} sResponse = WebRequestGetToString(sAddress, dData) d = JsToPyObject(sResponse) lExamples = d['example'] sText = Pluralize('Example', len(lExamples)) + ' of ' + sWordInfo + ' from wordnik.com\r\n\r\n' # for dExample in lExamples: print dExample.keys() for dExample in lExamples: if dExample.has_key('year'): sText += dExample['year'] + '\r\n' if dExample.has_key('title'): sText += dExample['title'] + '\r\n' if dExample.has_key('url'): sText += dExample['url'] + '\r\n' if dExample.has_key('display'): sText += dExample['display'] + '\r\n' sText += '\r\n' sExamples = sText.strip() sApiKey = '20f06c210d4894da53dcb065925e0158' # sAddress = 'http://words.bighugelabs.com/api/2/' + sApiKey + '/' + sWordInfo + ' + '/json' sAddress = 'http://words.bighugelabs.com/api/2/' + sApiKey + '/' + sWordInfo + '/' sResponse = WebRequestGetToString(sAddress) sResponse = sResponse.replace('|syn|', '|synonym|') sResponse = sResponse.replace('|ant|', '|antonym|') sResponse = sResponse.replace('|rel|', '|related term|') sResponse = sResponse.replace('|sim|', '|similar term|') sResponse = sResponse.replace('|usr|', '|user suggestion|') sResponse = sResponse.strip() lResults = sResponse.split('\n') sText = Pluralize('Result', len(lResults)) + ' from BigHugeLabs.com\r\n\r\n' for sResult in lResults: lParts = sResult.split('|') sText += lParts[0] + ', ' + lParts[1] + '\r\n' + lParts[2] + '\r\n\r\n' sText = (sDefinitions + '\r\n\r\n\r\n' + sExamples + '\r\n\r\n\r\n' + sText).strip() SayLine('Loading results and opening web page') sUrl = 'http://www.etymonline.com/index.php?search=' + sWordInfo.replace(' ', '+') + '&searchmode=none' os.startfile(sUrl) StringToFile(sText, sOutputFile)
jamalmazrui/InPy
WebClient_XtraWordInfo.py
Python
lgpl-3.0
3,600
0.012778
#!/usr/bin/python # coding=utf-8 ########################################################################## from diamond.collector import Collector from test import CollectorTestCase from test import get_collector_config from test import unittest from mock import patch from mock import Mock from etcdstat import EtcdCollector try: import simplejson as json except ImportError: import json ########################################################################## class TestEtcdCollector(CollectorTestCase): def setUp(self): config = get_collector_config('EtcdCollector', { 'interval': 10 }) self.collector = EtcdCollector(config, None) def test_import(self): self.assertTrue(EtcdCollector) @patch.object(Collector, 'publish') def test_should_work_with_real_follower_data(self, publish_mock): patch1_collector = patch.object( EtcdCollector, 'get_self_metrics', Mock(return_value=json.loads( self.getFixture('follower-self-metrics.json').getvalue()))) patch2_collector = patch.object( EtcdCollector, 'get_store_metrics', Mock(return_value=json.loads( self.getFixture('store-metrics2.json').getvalue()))) patch1_collector.start() patch2_collector.start() self.collector.collect() patch2_collector.stop() patch1_collector.stop() metrics = { 'self.is_leader': 0, 'self.sendAppendRequestCnt': 0, 'self.recvAppendRequestCnt': 79367, 'self.recvPkgRate': 6.557436727874493, 'self.recvBandwidthRate': 527.021189819273, 'store.compareAndDeleteFail': 0, 'store.watchers': 0, 'store.setsFail': 12, 'store.createSuccess': 1294, 'store.compareAndSwapFail': 136, 'store.compareAndSwapSuccess': 4839, 'store.deleteSuccess': 6, 'store.updateSuccess': 2, 'store.createFail': 0, 'store.getsSuccess': 396632, 'store.expireCount': 0, 'store.deleteFail': 6, 'store.updateFail': 0, 'store.getsFail': 255837, 'store.compareAndDeleteSuccess': 1239, 'store.setsSuccess': 98571, } self.assertPublishedMany(publish_mock, metrics) @patch.object(Collector, 'publish') def test_should_work_with_real_leader_data(self, publish_mock): patch1_collector = patch.object( EtcdCollector, 'get_self_metrics', Mock(return_value=json.loads( self.getFixture('leader-self-metrics.json').getvalue()))) patch2_collector = patch.object( EtcdCollector, 'get_store_metrics', Mock(return_value=json.loads( self.getFixture('store-metrics.json').getvalue()))) patch1_collector.start() patch2_collector.start() self.collector.collect() patch2_collector.stop() patch1_collector.stop() metrics = { 'self.is_leader': 1, 'self.sendAppendRequestCnt': 2097127, 'self.recvAppendRequestCnt': 5870, 'self.sendPkgRate': 11.763588080610418, 'self.sendBandwidthRate': 901.0908469747579, 'store.compareAndDeleteFail': 0, 'store.watchers': 51, 'store.setsFail': 123, 'store.createSuccess': 6468, 'store.compareAndSwapFail': 355, 'store.compareAndSwapSuccess': 9156, 'store.deleteSuccess': 2468, 'store.updateSuccess': 4576, 'store.createFail': 2508, 'store.getsSuccess': 1685131, 'store.expireCount': 0, 'store.deleteFail': 2138, 'store.updateFail': 0, 'store.getsFail': 922428, 'store.compareAndDeleteSuccess': 2047, 'store.setsSuccess': 733, } self.assertPublishedMany(publish_mock, metrics) self.setDocExample(collector=self.collector.__class__.__name__, metrics=metrics, defaultpath=self.collector.config['path']) ########################################################################## if __name__ == "__main__": unittest.main()
MichaelDoyle/Diamond
src/collectors/etcdstat/test/test_etcdstat.py
Python
mit
4,410
0.000227
# Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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 sys import unittest try: import simplejson as json except ImportError: import json # NOQA from libcloud.utils.py3 import httplib from libcloud.common.types import InvalidCredsError from libcloud.compute.base import NodeImage from libcloud.compute.drivers.digitalocean import DigitalOceanNodeDriver from libcloud.test import LibcloudTestCase, MockHttpTestCase from libcloud.test.file_fixtures import ComputeFileFixtures from libcloud.test.secrets import DIGITAL_OCEAN_PARAMS # class DigitalOceanTests(unittest.TestCase, TestCaseMixin): class DigitalOceanTests(LibcloudTestCase): def setUp(self): DigitalOceanNodeDriver.connectionCls.conn_classes = \ (None, DigitalOceanMockHttp) DigitalOceanMockHttp.type = None self.driver = DigitalOceanNodeDriver(*DIGITAL_OCEAN_PARAMS) def test_authentication(self): DigitalOceanMockHttp.type = 'UNAUTHORIZED_CLIENT' self.assertRaises(InvalidCredsError, self.driver.list_nodes) def test_list_images_success(self): images = self.driver.list_images() self.assertTrue(len(images) >= 1) image = images[0] self.assertTrue(image.id is not None) self.assertTrue(image.name is not None) def test_list_sizes_success(self): sizes = self.driver.list_sizes() self.assertTrue(len(sizes) >= 1) size = sizes[0] self.assertTrue(size.id is not None) self.assertEqual(size.name, '512MB') self.assertEqual(size.ram, 512) size = sizes[4] self.assertTrue(size.id is not None) self.assertEqual(size.name, '8GB') self.assertEqual(size.ram, 8 * 1024) def test_list_locations_success(self): locations = self.driver.list_locations() self.assertTrue(len(locations) >= 1) location = locations[0] self.assertEqual(location.id, '1') self.assertEqual(location.name, 'New York 1') def test_list_nodes_success(self): nodes = self.driver.list_nodes() self.assertEqual(len(nodes), 1) self.assertEqual(nodes[0].name, 'test-2') self.assertEqual(nodes[0].public_ips, []) def test_create_node_invalid_size(self): image = NodeImage(id='invalid', name=None, driver=self.driver) size = self.driver.list_sizes()[0] location = self.driver.list_locations()[0] DigitalOceanMockHttp.type = 'INVALID_IMAGE' expected_msg = r'You specified an invalid image for Droplet creation. \(code: 404\)' self.assertRaisesRegexp(Exception, expected_msg, self.driver.create_node, name='test', size=size, image=image, location=location) def test_reboot_node_success(self): node = self.driver.list_nodes()[0] result = self.driver.reboot_node(node) self.assertTrue(result) def test_destroy_node_success(self): node = self.driver.list_nodes()[0] result = self.driver.destroy_node(node) self.assertTrue(result) def test_ex_rename_node_success(self): node = self.driver.list_nodes()[0] result = self.driver.ex_rename_node(node, 'fedora helios') self.assertTrue(result) def test_ex_list_ssh_keys(self): keys = self.driver.ex_list_ssh_keys() self.assertEqual(len(keys), 1) self.assertEqual(keys[0].id, 7717) self.assertEqual(keys[0].name, 'test1') self.assertEqual(keys[0].pub_key, None) def test_ex_destroy_ssh_key(self): key = self.driver.ex_list_ssh_keys()[0] result = self.driver.ex_destroy_ssh_key(key.id) self.assertTrue(result) class DigitalOceanMockHttp(MockHttpTestCase): fixtures = ComputeFileFixtures('digitalocean') def _regions(self, method, url, body, headers): body = self.fixtures.load('list_locations.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _images(self, method, url, body, headers): body = self.fixtures.load('list_images.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _sizes(self, method, url, body, headers): body = self.fixtures.load('list_sizes.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _droplets(self, method, url, body, headers): body = self.fixtures.load('list_nodes.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _droplets_new_INVALID_IMAGE(self, method, url, body, headers): # reboot_node body = self.fixtures.load('error_invalid_image.json') return (httplib.NOT_FOUND, body, {}, httplib.responses[httplib.NOT_FOUND]) def _droplets_119461_reboot(self, method, url, body, headers): # reboot_node body = self.fixtures.load('reboot_node.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _droplets_119461_destroy(self, method, url, body, headers): # destroy_node self.assertUrlContainsQueryParams(url, {'scrub_data': '1'}) body = self.fixtures.load('destroy_node.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _droplets_119461_rename(self, method, url, body, headers): # reboot_node self.assertUrlContainsQueryParams(url, {'name': 'fedora helios'}) body = self.fixtures.load('ex_rename_node.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _ssh_keys(self, method, url, body, headers): body = self.fixtures.load('ex_list_ssh_keys.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _ssh_keys_7717_destroy(self, method, url, body, headers): # destroy_ssh_key body = self.fixtures.load('ex_destroy_ssh_key.json') return (httplib.OK, body, {}, httplib.responses[httplib.OK]) def _droplets_UNAUTHORIZED_CLIENT(self, method, url, body, headers): body = self.fixtures.load('error.txt') return (httplib.FOUND, body, {}, httplib.responses[httplib.FOUND]) if __name__ == '__main__': sys.exit(unittest.main())
elastacloud/libcloud
libcloud/test/compute/test_digitalocean.py
Python
apache-2.0
6,980
0.00043
# Copyright 2015 Mirantis Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import sys from manila.cmd import api as manila_api from manila import test from manila import version CONF = manila_api.CONF class ManilaCmdApiTestCase(test.TestCase): def setUp(self): super(ManilaCmdApiTestCase, self).setUp() sys.argv = ['manila-api'] def test_main(self): self.mock_object(manila_api.log, 'setup') self.mock_object(manila_api.log, 'register_options') self.mock_object(manila_api.utils, 'monkey_patch') self.mock_object(manila_api.service, 'process_launcher') self.mock_object(manila_api.service, 'WSGIService') manila_api.main() process_launcher = manila_api.service.process_launcher process_launcher.assert_called_once_with() self.assertTrue(process_launcher.return_value.launch_service.called) self.assertTrue(process_launcher.return_value.wait.called) self.assertEqual('manila', CONF.project) self.assertEqual(version.version_string(), CONF.version) manila_api.log.setup.assert_called_once_with(CONF, "manila") manila_api.log.register_options.assert_called_once_with(CONF) manila_api.utils.monkey_patch.assert_called_once_with() manila_api.service.WSGIService.assert_called_once_with('osapi_share')
bswartz/manila
manila/tests/cmd/test_api.py
Python
apache-2.0
1,877
0
#!/bin/python #author: tobias mueller 13.6.13 #byteplay test from sys import version_info from dis import dis if version_info.major == 3: if version_info.minor < 6:from byteplay import * else:from wbyteplay import * else:from byteplay2 import * from pprint import pprint def f(a, b): res = a + b return res def g(a, b): res = a + b if a < b else b + a r = 0 for a in range(res): r += 1 return r or 2 for x in (f, g): #get byte code for f c = Code.from_code(x.__code__) pprint(c.code) #generate byte code cnew = c.to_code() x.__code__ = cnew dis(x) print(x(3,5))
serprex/byteplay
sanitytest.py
Python
lgpl-2.1
640
0.023438
#!/usr/bin/env python from __future__ import print_function import json, sys from common_paths import * def assert_non_empty_string(obj, field): assert field in obj, 'Missing field "%s"' % field assert isinstance(obj[field], basestring), \ 'Field "%s" must be a string' % field assert len(obj[field]) > 0, 'Field "%s" must not be empty' % field def assert_non_empty_list(obj, field): assert isinstance(obj[field], list), \ '%s must be a list' % field assert len(obj[field]) > 0, \ '%s list must not be empty' % field def assert_non_empty_dict(obj, field): assert isinstance(obj[field], dict), \ '%s must be a dict' % field assert len(obj[field]) > 0, \ '%s dict must not be empty' % field def assert_contains(obj, field): assert field in obj, 'Must contain field "%s"' % field def assert_string_from(obj, field, items): assert obj[field] in items, \ 'Field "%s" must be from: %s' % (field, str(items)) def assert_string_or_list_items_from(obj, field, items): if isinstance(obj[field], basestring): assert_string_from(obj, field, items) return assert isinstance(obj[field], list), "%s must be a list!" % field for allowed_value in obj[field]: assert allowed_value != '*', "Wildcard is not supported for lists!" assert allowed_value in items, \ 'Field "%s" must be from: %s' % (field, str(items)) def assert_contains_only_fields(obj, expected_fields): for expected_field in expected_fields: assert_contains(obj, expected_field) for actual_field in obj: assert actual_field in expected_fields, \ 'Unexpected field "%s".' % actual_field def assert_value_unique_in(value, used_values): assert value not in used_values, 'Duplicate value "%s"!' % str(value) used_values[value] = True def assert_valid_artifact(exp_pattern, artifact_key, schema): if isinstance(schema, list): assert_string_or_list_items_from(exp_pattern, artifact_key, ["*"] + schema) return for sub_artifact_key, sub_schema in schema.iteritems(): assert_valid_artifact(exp_pattern[artifact_key], sub_artifact_key, sub_schema) def validate(spec_json, details): """ Validates the json specification for generating tests. """ details['object'] = spec_json assert_contains_only_fields(spec_json, ["specification", "test_expansion_schema", "excluded_tests"]) assert_non_empty_list(spec_json, "specification") assert_non_empty_dict(spec_json, "test_expansion_schema") assert_non_empty_list(spec_json, "excluded_tests") specification = spec_json['specification'] test_expansion_schema = spec_json['test_expansion_schema'] excluded_tests = spec_json['excluded_tests'] valid_test_expansion_fields = ['name'] + test_expansion_schema.keys() # Validate each single spec. for spec in specification: details['object'] = spec # Validate required fields for a single spec. assert_contains_only_fields(spec, ['name', 'title', 'description', 'specification_url', 'test_expansion']) assert_non_empty_string(spec, 'name') assert_non_empty_string(spec, 'title') assert_non_empty_string(spec, 'description') assert_non_empty_string(spec, 'specification_url') assert_non_empty_list(spec, 'test_expansion') # Validate spec's test expansion. used_spec_names = {} for spec_exp in spec['test_expansion']: details['object'] = spec_exp assert_non_empty_string(spec_exp, 'name') # The name is unique in same expansion group. assert_value_unique_in((spec_exp['expansion'], spec_exp['name']), used_spec_names) assert_contains_only_fields(spec_exp, valid_test_expansion_fields) for artifact in test_expansion_schema: details['test_expansion_field'] = artifact assert_valid_artifact(spec_exp, artifact, test_expansion_schema[artifact]) del details['test_expansion_field'] # Validate the test_expansion schema members. details['object'] = test_expansion_schema assert_contains_only_fields(test_expansion_schema, ['expansion', 'source_scheme', 'opt_in_method', 'context_nesting', 'redirection', 'subresource', 'origin', 'expectation']) # Validate excluded tests. details['object'] = excluded_tests for excluded_test_expansion in excluded_tests: assert_contains_only_fields(excluded_test_expansion, valid_test_expansion_fields) del details['object'] def assert_valid_spec_json(spec_json): error_details = {} try: validate(spec_json, error_details) except AssertionError as err: print('ERROR:', err.message) print(json.dumps(error_details, indent=4)) sys.exit(1) def main(): spec_json = load_spec_json(); assert_valid_spec_json(spec_json) print("Spec JSON is valid.") if __name__ == '__main__': main()
Varentsov/servo
tests/wpt/web-platform-tests/mixed-content/generic/tools/spec_validator.py
Python
mpl-2.0
5,868
0.001363
# -*- coding: utf-8 -*- import logging import commands import simplejson import os import os.path import openerp import time import random import subprocess import simplejson import werkzeug import werkzeug.wrappers _logger = logging.getLogger(__name__) from openerp import http from openerp.http import request # Those are the builtin raspberry pi USB modules, they should # not appear in the list of connected devices. BANNED_DEVICES = set([ "0424:9514", # Standard Microsystem Corp. Builtin Ethernet module "1d6b:0002", # Linux Foundation 2.0 root hub "0424:ec00", # Standard Microsystem Corp. Other Builtin Ethernet module ]) # drivers modules must add to drivers an object with a get_status() method # so that 'status' can return the status of all active drivers drivers = {} class Proxy(http.Controller): def get_status(self): statuses = {} for driver in drivers: statuses[driver] = drivers[driver].get_status() return statuses @http.route('/hw_proxy/hello', type='http', auth='none', cors='*') def hello(self): return "ping" @http.route('/hw_proxy/handshake', type='json', auth='none', cors='*') def handshake(self): return True @http.route('/hw_proxy/status', type='http', auth='none', cors='*') def status_http(self): resp = """ <!DOCTYPE HTML> <html> <head> <title>Odoo's PosBox</title> <style> body { width: 480px; margin: 60px auto; font-family: sans-serif; text-align: justify; color: #6B6B6B; } .device { border-bottom: solid 1px rgb(216,216,216); padding: 9px; } .device:nth-child(2n) { background:rgb(240,240,240); } </style> </head> <body> <h1>Hardware Status</h1> <p>The list of enabled drivers and their status</p> """ statuses = self.get_status() for driver in statuses: status = statuses[driver] if status['status'] == 'connecting': color = 'black' elif status['status'] == 'connected': color = 'green' else: color = 'red' resp += "<h3 style='color:"+color+";'>"+driver+' : '+status['status']+"</h3>\n" resp += "<ul>\n" for msg in status['messages']: resp += '<li>'+msg+'</li>\n' resp += "</ul>\n" resp += """ <h2>Connected Devices</h2> <p>The list of connected USB devices as seen by the posbox</p> """ devices = commands.getoutput("lsusb").split('\n') count = 0 resp += "<div class='devices'>\n" for device in devices: device_name = device[device.find('ID')+2:] device_id = device_name.split()[0] if not (device_id in BANNED_DEVICES): resp+= "<div class='device' data-device='"+device+"'>"+device_name+"</div>\n" count += 1 if count == 0: resp += "<div class='device'>No USB Device Found</div>" resp += "</div>\n" resp += """ <h2>Add New Printer</h2> <p> Copy and paste your printer's device description in the form below. You can find your printer's description in the device list above. If you find that your printer works well, please send your printer's description to <a href='mailto:support@odoo.com'> support@openerp.com</a> so that we can add it to the default list of supported devices. </p> <form action='/hw_proxy/escpos/add_supported_device' method='GET'> <input type='text' style='width:400px' name='device_string' placeholder='123a:b456 Sample Device description' /> <input type='submit' value='submit' /> </form> <h2>Reset To Defaults</h2> <p>If the added devices cause problems, you can <a href='/hw_proxy/escpos/reset_supported_devices'>Reset the device list to factory default.</a> This operation cannot be undone.</p> """ resp += "</body>\n</html>\n\n" return request.make_response(resp,{ 'Cache-Control': 'no-cache', 'Content-Type': 'text/html; charset=utf-8', 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'GET', }) @http.route('/hw_proxy/status_json', type='json', auth='none', cors='*') def status_json(self): return self.get_status() @http.route('/hw_proxy/scan_item_success', type='json', auth='none', cors='*') def scan_item_success(self, ean): """ A product has been scanned with success """ print 'scan_item_success: ' + str(ean) @http.route('/hw_proxy/scan_item_error_unrecognized', type='json', auth='none', cors='*') def scan_item_error_unrecognized(self, ean): """ A product has been scanned without success """ print 'scan_item_error_unrecognized: ' + str(ean) @http.route('/hw_proxy/help_needed', type='json', auth='none', cors='*') def help_needed(self): """ The user wants an help (ex: light is on) """ print "help_needed" @http.route('/hw_proxy/help_canceled', type='json', auth='none', cors='*') def help_canceled(self): """ The user stops the help request """ print "help_canceled" @http.route('/hw_proxy/payment_request', type='json', auth='none', cors='*') def payment_request(self, price): """ The PoS will activate the method payment """ print "payment_request: price:"+str(price) return 'ok' @http.route('/hw_proxy/payment_status', type='json', auth='none', cors='*') def payment_status(self): print "payment_status" return { 'status':'waiting' } @http.route('/hw_proxy/payment_cancel', type='json', auth='none', cors='*') def payment_cancel(self): print "payment_cancel" @http.route('/hw_proxy/transaction_start', type='json', auth='none', cors='*') def transaction_start(self): print 'transaction_start' @http.route('/hw_proxy/transaction_end', type='json', auth='none', cors='*') def transaction_end(self): print 'transaction_end' @http.route('/hw_proxy/cashier_mode_activated', type='json', auth='none', cors='*') def cashier_mode_activated(self): print 'cashier_mode_activated' @http.route('/hw_proxy/cashier_mode_deactivated', type='json', auth='none', cors='*') def cashier_mode_deactivated(self): print 'cashier_mode_deactivated' @http.route('/hw_proxy/open_cashbox', type='json', auth='none', cors='*') def open_cashbox(self): print 'open_cashbox' @http.route('/hw_proxy/print_receipt', type='json', auth='none', cors='*') def print_receipt(self, receipt): print 'print_receipt' + str(receipt) @http.route('/hw_proxy/is_scanner_connected', type='json', auth='none', cors='*') def is_scanner_connected(self, receipt): print 'is_scanner_connected?' return False @http.route('/hw_proxy/scanner', type='json', auth='none', cors='*') def scanner(self, receipt): print 'scanner' time.sleep(10) return '' @http.route('/hw_proxy/log', type='json', auth='none', cors='*') def log(self, arguments): _logger.info(' '.join(str(v) for v in arguments)) @http.route('/hw_proxy/print_pdf_invoice', type='json', auth='none', cors='*') def print_pdf_invoice(self, pdfinvoice): print 'print_pdf_invoice' + str(pdfinvoice)
exploreodoo/datStruct
odoo/addons/hw_proxy/controllers/main.py
Python
gpl-2.0
7,800
0.005769
from system.core.controller import * from rauth import OAuth2Service from flask import redirect, request import urllib2 import json from time import strftime facebook = OAuth2Service( name='facebook', base_url='https://graph.facebook.com/', access_token_url='/oauth/access_token', authorize_url='https://www.facebook.com/dialog/oauth', client_id='259154491127882', client_secret='c5b9a2e1e25bfa25abc75a9cd2af450a', ) app_id = "259154491127882" redirect_uri = 'http://localhost:5000/' params = { 'scope': 'read_stream', 'response_type': 'code', 'redirect_uri': redirect_uri } url = facebook.get_authorize_url(**params) class Users(Controller): def __init__(self, action): super(Users, self).__init__(action) self.load_model('User') self.load_model('Event') self.db = self._app.db # routes['/'] = "Users#index" def index(self): if 'user' in session: user_rides = self.models['Event'].get_events_by_user(session['user']['user_info']['user_id']) if user_rides['status']: for ride in user_rides['events']: result = self.models['Event'].get_users_by_ride(ride['ride_id']) ride['users_in_ride'] = result['users'] ride['ride_date'] = ride['ride_date'].strftime('%x') return self.load_view('index.html', user_rides=user_rides['events']) return self.load_view('index.html') # routes['/login'] = "Users#login" def login(self): if 'user' in session: return redirect('/') return self.load_view('login.html') # routes['/logout'] = "Users#logout" def logout(self): if 'user' in session: flash('You have successfully logged out', 'success') session.clear() return redirect('/') # routes['/user/<user_id>'] = "Users#show_user" def show_user(self, user_id): if 'user' in session: user = self.models['User'].get_user(user_id) if user['status']: return self.load_view('user.html', user=user['user']) return redirect('/') return redirect('/') # routes['/user/inbox'] = "Users#show_inbox" def show_inbox(self): if 'user' in session: return self.load_view('inbox.html') return redirect('/') # routes['POST']['/login/process'] = "Users#login_process" def login_process(self): if 'user' in session: return redirect('/') return redirect("https://www.facebook.com/dialog/oauth?client_id="+app_id+"&redirect_uri=http://localhost:5000/oauth-authorized/") def oauth_authorized(self): code = request.args.get('code') json_str = urllib2.urlopen("https://graph.facebook.com/v2.3/oauth/access_token?client_id=" + app_id + "&redirect_uri=http://localhost:5000/oauth-authorized/&client_secret" "=c5b9a2e1e25bfa25abc75a9cd2af450a&code=" + code).read() token = json.loads(json_str) token = token['access_token'] fb_session = facebook.get_session(token) register_data = fb_session.get('/me?fields=id,first_name,last_name,email', params={'format': 'json'}).json() user_picture = fb_session.get('/me?fields=picture', params={'format': 'json'}).json() if register_data: user = self.models['User'].add_user(register_data) if user['status']: # just registered session['new_user'] = True # already registered session['user'] = register_data session['user']['user_info'] = self.models['User'].get_user_by_fbid(session['user']['id'])['user'] session['user']['user_info']['user_id'] = session['user']['user_info']['user_id'] session['user']['picture'] = user_picture['picture']['data']['url'] session['rides_in'] = [] return redirect('/') def register_process(self): user = self.models['User'].register(request.form, session['user']['id']) if user['status']: # they were updated session.pop('new_user') session['user']['city'] = user['user']['city'] return redirect('/') # they weren't updated flash('There was a problem with your inputs, please try again') return redirect('/')
RydrDojo/Ridr_app
app/controllers/Users.py
Python
mit
4,431
0.00316
from __future__ import unicode_literals from frappe import _ def get_data(): return [ { "label": _("Documents"), "icon": "icon-star", "items": [ { "type": "doctype", "name": "Employee", "description": _("Employee records."), }, { "type": "doctype", "name": "Leave Application", "description": _("Applications for leave."), }, { "type": "doctype", "name": "Expense Claim", "description": _("Claims for company expense."), }, { "type": "doctype", "name": "Attendance", "description": _("Attendance record."), }, { "type": "doctype", "name": "Salary Slip", "description": _("Monthly salary statement."), }, { "type": "doctype", "name": "Appraisal", "description": _("Performance appraisal."), }, { "type": "doctype", "name": "Job Applicant", "description": _("Applicant for a Job."), }, { "type": "doctype", "name": "Job Opening", "description": _("Opening for a Job."), }, { "type": "doctype", "name": "Offer Letter", "description": _("Offer candidate a Job."), }, ] }, { "label": _("Tools"), "icon": "icon-wrench", "items": [ { "type": "doctype", "name": "Salary Manager", "label": _("Process Payroll"), "description":_("Generate Salary Slips"), "hide_count": True }, { "type": "doctype", "name": "Timesheet Report", "label": _("Timesheet Report"), "description":_("Attendance Report"), "hide_count": True }, { "type": "doctype", "name": "Upload Attendance", "description":_("Upload attendance from a .csv file"), "hide_count": True }, { "type": "doctype", "name": "Leave Control Panel", "label": _("Leave Allocation Tool"), "description":_("Allocate leaves for the year."), "hide_count": True }, ] }, { "label": _("Setup"), "icon": "icon-cog", "items": [ { "type": "doctype", "name": "HR Settings", "description": _("Settings for HR Module") }, { "type": "doctype", "name": "Employment Type", "description": _("Types of employment (permanent, contract, intern etc.).") }, { "type": "doctype", "name": "Branch", "description": _("Organization branch master.") }, { "type": "doctype", "name": "Department", "description": _("Organization unit (department) master.") }, { "type": "doctype", "name": "Designation", "description": _("Employee designation (e.g. CEO, Director etc.).") }, { "type": "doctype", "name": "Salary Structure", "description": _("Salary template master.") }, { "type": "doctype", "name": "Earning Type", "description": _("Salary components.") }, { "type": "doctype", "name": "Deduction Type", "description": _("Tax and other salary deductions.") }, { "type": "doctype", "name": "Leave Allocation", "description": _("Allocate leaves for a period.") }, { "type": "doctype", "name":"Leave Type", "description": _("Type of leaves like casual, sick etc."), }, { "type": "doctype", "name": "Holiday List", "description": _("Holiday master.") }, { "type": "doctype", "name": "Leave Block List", "description": _("Block leave applications by department.") }, { "type": "doctype", "name": "Appraisal Template", "description": _("Template for performance appraisals.") }, { "type": "doctype", "name": "Expense Claim Type", "description": _("Types of Expense Claim.") }, { "type": "doctype", "name": "Email Account", "description": _("Setup incoming server for jobs email id. (e.g. jobs@example.com)") }, ] }, { "label": _("Standard Reports"), "icon": "icon-list", "items": [ { "type": "report", "is_query_report": True, "name": "Employee Leave Balance", "doctype": "Leave Application" }, { "type": "report", "is_query_report": True, "name": "Employee Birthday", "doctype": "Employee" }, { "type": "report", "name": "Employee Information", "doctype": "Employee" }, { "type": "report", "is_query_report": True, "name": "Monthly Salary Register", "doctype": "Salary Slip" }, { "type": "report", "is_query_report": True, "name": "Monthly Attendance Sheet", "doctype": "Attendance" }, ] }, ]
indictranstech/tele-erpnext
erpnext/config/hr.py
Python
agpl-3.0
4,677
0.044901
#!/usr/bin/python # $Id:$ import ctypes import queue import pyglet from pyglet.window.win32 import kernel32, user32, constants, types class MTWin32EventLoop(pyglet.app.win32.Win32EventLoop): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Force immediate creation of an event queue on this thread msg = types.MSG() user32.PeekMessageW(ctypes.byref(msg), 0, constants.WM_USER, constants.WM_USER, constants.PM_NOREMOVE) self._event_thread = kernel32.GetCurrentThreadId() self._post_event_queue = queue.Queue() def post_event(self, dispatcher, event, *args): self._post_event_queue.put((dispatcher, event, args)) # Nudge the event loop with a message it will discard user32.PostThreadMessageW(self._event_thread, constants.WM_USER, 0, 0) def _dispatch_posted_events(self): # Dispatch (synchronised) queued events while True: try: dispatcher, event, args = self._post_event_queue.get(False) except queue.Empty: break dispatcher.dispatch_event(event, *args) def run(self): self._setup() self._timer_proc = types.TIMERPROC(self._timer_func) self._timer = timer = user32.SetTimer(0, 0, 0, self._timer_proc) self._polling = False self._allow_polling = False msg = types.MSG() self.dispatch_event('on_enter') self._dispatch_posted_events() while not self.has_exit: if self._polling: while user32.PeekMessageW(ctypes.byref(msg), 0, 0, 0, constants.PM_REMOVE): user32.TranslateMessage(ctypes.byref(msg)) user32.DispatchMessageW(ctypes.byref(msg)) self._timer_func(0, 0, timer, 0) else: user32.GetMessageW(ctypes.byref(msg), 0, 0, 0) user32.TranslateMessage(ctypes.byref(msg)) user32.DispatchMessageW(ctypes.byref(msg)) # Manual idle event msg_types = \ user32.GetQueueStatus(constants.QS_ALLINPUT) & 0xffff0000 if (msg.message != constants.WM_TIMER and not msg_types & ~(constants.QS_TIMER << 16)): self._timer_func(0, 0, timer, 0) self._dispatch_posted_events() self.dispatch_event('on_exit') pyglet.app.EventLoop = MTWin32EventLoop
bitcraft/pyglet
contrib/experimental/mt_media/mt_app_win32.py
Python
bsd-3-clause
2,590
0.001158
from django.apps import AppConfig class DesarrollowebConfig(AppConfig): name = 'desarrolloweb'
z1gm4/desarrollo_web_udp
desarrolloweb/apps.py
Python
gpl-3.0
101
0
from __future__ import unicode_literals from django.core.exceptions import PermissionDenied from django.core.mail import send_mail from django.core import validators from django.db import models from django.db.models.manager import EmptyManager from django.utils.crypto import get_random_string, salted_hmac from django.utils import six from django.utils.translation import ugettext_lazy as _ from django.utils import timezone from django.contrib import auth from django.contrib.auth.hashers import ( check_password, make_password, is_password_usable) from django.contrib.auth.signals import user_logged_in from django.contrib.contenttypes.models import ContentType from django.utils.encoding import python_2_unicode_compatible def update_last_login(sender, user, **kwargs): """ A signal receiver which updates the last_login date for the user logging in. """ user.last_login = timezone.now() user.save(update_fields=['last_login']) user_logged_in.connect(update_last_login) class PermissionManager(models.Manager): def get_by_natural_key(self, codename, app_label, model): return self.get( codename=codename, content_type=ContentType.objects.db_manager(self.db).get_by_natural_key(app_label, model), ) @python_2_unicode_compatible class Permission(models.Model): """ The permissions system provides a way to assign permissions to specific users and groups of users. The permission system is used by the Django admin site, but may also be useful in your own code. The Django admin site uses permissions as follows: - The "add" permission limits the user's ability to view the "add" form and add an object. - The "change" permission limits a user's ability to view the change list, view the "change" form and change an object. - The "delete" permission limits the ability to delete an object. Permissions are set globally per type of object, not per specific object instance. It is possible to say "Mary may change news stories," but it's not currently possible to say "Mary may change news stories, but only the ones she created herself" or "Mary may only change news stories that have a certain status or publication date." Three basic permissions -- add, change and delete -- are automatically created for each Django model. """ name = models.CharField(_('name'), max_length=255) content_type = models.ForeignKey(ContentType) codename = models.CharField(_('codename'), max_length=100) objects = PermissionManager() class Meta: verbose_name = _('permission') verbose_name_plural = _('permissions') unique_together = (('content_type', 'codename'),) ordering = ('content_type__app_label', 'content_type__model', 'codename') def __str__(self): return "%s | %s | %s" % ( six.text_type(self.content_type.app_label), six.text_type(self.content_type), six.text_type(self.name)) def natural_key(self): return (self.codename,) + self.content_type.natural_key() natural_key.dependencies = ['contenttypes.contenttype'] class GroupManager(models.Manager): """ The manager for the auth's Group model. """ def get_by_natural_key(self, name): return self.get(name=name) @python_2_unicode_compatible class Group(models.Model): """ Groups are a generic way of categorizing users to apply permissions, or some other label, to those users. A user can belong to any number of groups. A user in a group automatically has all the permissions granted to that group. For example, if the group Site editors has the permission can_edit_home_page, any user in that group will have that permission. Beyond permissions, groups are a convenient way to categorize users to apply some label, or extended functionality, to them. For example, you could create a group 'Special users', and you could write code that would do special things to those users -- such as giving them access to a members-only portion of your site, or sending them members-only email messages. """ name = models.CharField(_('name'), max_length=80, unique=True) permissions = models.ManyToManyField(Permission, verbose_name=_('permissions'), blank=True) objects = GroupManager() class Meta: verbose_name = _('group') verbose_name_plural = _('groups') def __str__(self): return self.name def natural_key(self): return (self.name,) class BaseUserManager(models.Manager): @classmethod def normalize_email(cls, email): """ Normalize the address by lowercasing the domain part of the email address. """ email = email or '' try: email_name, domain_part = email.strip().rsplit('@', 1) except ValueError: pass else: email = '@'.join([email_name, domain_part.lower()]) return email def make_random_password(self, length=10, allowed_chars='abcdefghjkmnpqrstuvwxyz' 'ABCDEFGHJKLMNPQRSTUVWXYZ' '23456789'): """ Generates a random password with the given length and given allowed_chars. Note that the default value of allowed_chars does not have "I" or "O" or letters and digits that look similar -- just to avoid confusion. """ return get_random_string(length, allowed_chars) def get_by_natural_key(self, username): return self.get(**{self.model.USERNAME_FIELD: username}) class UserManager(BaseUserManager): def _create_user(self, username, email, password, is_staff, is_superuser, **extra_fields): """ Creates and saves a User with the given username, email and password. """ now = timezone.now() if not username: raise ValueError('The given username must be set') email = self.normalize_email(email) user = self.model(username=username, email=email, is_staff=is_staff, is_active=True, is_superuser=is_superuser, date_joined=now, **extra_fields) user.set_password(password) user.save(using=self._db) return user def create_user(self, username, email=None, password=None, **extra_fields): return self._create_user(username, email, password, False, False, **extra_fields) def create_superuser(self, username, email, password, **extra_fields): return self._create_user(username, email, password, True, True, **extra_fields) @python_2_unicode_compatible class AbstractBaseUser(models.Model): password = models.CharField(_('password'), max_length=128) last_login = models.DateTimeField(_('last login'), blank=True, null=True) is_active = True REQUIRED_FIELDS = [] class Meta: abstract = True def get_username(self): "Return the identifying username for this User" return getattr(self, self.USERNAME_FIELD) def __str__(self): return self.get_username() def natural_key(self): return (self.get_username(),) def is_anonymous(self): """ Always returns False. This is a way of comparing User objects to anonymous users. """ return False def is_authenticated(self): """ Always return True. This is a way to tell if the user has been authenticated in templates. """ return True def set_password(self, raw_password): self.password = make_password(raw_password) def check_password(self, raw_password): """ Returns a boolean of whether the raw_password was correct. Handles hashing formats behind the scenes. """ def setter(raw_password): self.set_password(raw_password) self.save(update_fields=["password"]) return check_password(raw_password, self.password, setter) def set_unusable_password(self): # Sets a value that will never be a valid hash self.password = make_password(None) def has_usable_password(self): return is_password_usable(self.password) def get_full_name(self): raise NotImplementedError('subclasses of AbstractBaseUser must provide a get_full_name() method') def get_short_name(self): raise NotImplementedError('subclasses of AbstractBaseUser must provide a get_short_name() method.') def get_session_auth_hash(self): """ Returns an HMAC of the password field. """ key_salt = "django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash" return salted_hmac(key_salt, self.password).hexdigest() # A few helper functions for common logic between User and AnonymousUser. def _user_get_all_permissions(user, obj): permissions = set() for backend in auth.get_backends(): if hasattr(backend, "get_all_permissions"): permissions.update(backend.get_all_permissions(user, obj)) return permissions def _user_has_perm(user, perm, obj): """ A backend can raise `PermissionDenied` to short-circuit permission checking. """ for backend in auth.get_backends(): if not hasattr(backend, 'has_perm'): continue try: if backend.has_perm(user, perm, obj): return True except PermissionDenied: return False return False def _user_has_module_perms(user, app_label): """ A backend can raise `PermissionDenied` to short-circuit permission checking. """ for backend in auth.get_backends(): if not hasattr(backend, 'has_module_perms'): continue try: if backend.has_module_perms(user, app_label): return True except PermissionDenied: return False return False class PermissionsMixin(models.Model): """ A mixin class that adds the fields and methods necessary to support Django's Group and Permission model using the ModelBackend. """ is_superuser = models.BooleanField(_('superuser status'), default=False, help_text=_('Designates that this user has all permissions without ' 'explicitly assigning them.')) groups = models.ManyToManyField(Group, verbose_name=_('groups'), blank=True, help_text=_('The groups this user belongs to. A user will ' 'get all permissions granted to each of ' 'their groups.'), related_name="user_set", related_query_name="user") user_permissions = models.ManyToManyField(Permission, verbose_name=_('user permissions'), blank=True, help_text=_('Specific permissions for this user.'), related_name="user_set", related_query_name="user") class Meta: abstract = True def get_group_permissions(self, obj=None): """ Returns a list of permission strings that this user has through their groups. This method queries all available auth backends. If an object is passed in, only permissions matching this object are returned. """ permissions = set() for backend in auth.get_backends(): if hasattr(backend, "get_group_permissions"): permissions.update(backend.get_group_permissions(self, obj)) return permissions def get_all_permissions(self, obj=None): return _user_get_all_permissions(self, obj) def has_perm(self, perm, obj=None): """ Returns True if the user has the specified permission. This method queries all available auth backends, but returns immediately if any backend returns True. Thus, a user who has permission from a single auth backend is assumed to have permission in general. If an object is provided, permissions for this specific object are checked. """ # Active superusers have all permissions. if self.is_active and self.is_superuser: return True # Otherwise we need to check the backends. return _user_has_perm(self, perm, obj) def has_perms(self, perm_list, obj=None): """ Returns True if the user has each of the specified permissions. If object is passed, it checks if the user has all required perms for this object. """ for perm in perm_list: if not self.has_perm(perm, obj): return False return True def has_module_perms(self, app_label): """ Returns True if the user has any permissions in the given app label. Uses pretty much the same logic as has_perm, above. """ # Active superusers have all permissions. if self.is_active and self.is_superuser: return True return _user_has_module_perms(self, app_label) class AbstractUser(AbstractBaseUser, PermissionsMixin): """ An abstract base class implementing a fully featured User model with admin-compliant permissions. Username, password and email are required. Other fields are optional. """ username = models.CharField(_('username'), max_length=30, unique=True, help_text=_('Required. 30 characters or fewer. Letters, digits and ' '@/./+/-/_ only.'), validators=[ validators.RegexValidator(r'^[\w.@+-]+$', _('Enter a valid username. ' 'This value may contain only letters, numbers ' 'and @/./+/-/_ characters.'), 'invalid'), ], error_messages={ 'unique': _("A user with that username already exists."), }) first_name = models.CharField(_('first name'), max_length=30, blank=True) last_name = models.CharField(_('last name'), max_length=30, blank=True) email = models.EmailField(_('email address'), blank=True) is_staff = models.BooleanField(_('staff status'), default=False, help_text=_('Designates whether the user can log into this admin ' 'site.')) is_active = models.BooleanField(_('active'), default=True, help_text=_('Designates whether this user should be treated as ' 'active. Unselect this instead of deleting accounts.')) date_joined = models.DateTimeField(_('date joined'), default=timezone.now) objects = UserManager() USERNAME_FIELD = 'username' REQUIRED_FIELDS = ['email'] class Meta: verbose_name = _('user') verbose_name_plural = _('users') abstract = True def get_full_name(self): """ Returns the first_name plus the last_name, with a space in between. """ full_name = '%s %s' % (self.first_name, self.last_name) return full_name.strip() def get_short_name(self): "Returns the short name for the user." return self.first_name def email_user(self, subject, message, from_email=None, **kwargs): """ Sends an email to this User. """ send_mail(subject, message, from_email, [self.email], **kwargs) class User(AbstractUser): """ Users within the Django authentication system are represented by this model. Username, password and email are required. Other fields are optional. """ class Meta(AbstractUser.Meta): swappable = 'AUTH_USER_MODEL' @python_2_unicode_compatible class AnonymousUser(object): id = None pk = None username = '' is_staff = False is_active = False is_superuser = False _groups = EmptyManager(Group) _user_permissions = EmptyManager(Permission) def __init__(self): pass def __str__(self): return 'AnonymousUser' def __eq__(self, other): return isinstance(other, self.__class__) def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return 1 # instances always return the same hash value def save(self): raise NotImplementedError("Django doesn't provide a DB representation for AnonymousUser.") def delete(self): raise NotImplementedError("Django doesn't provide a DB representation for AnonymousUser.") def set_password(self, raw_password): raise NotImplementedError("Django doesn't provide a DB representation for AnonymousUser.") def check_password(self, raw_password): raise NotImplementedError("Django doesn't provide a DB representation for AnonymousUser.") def _get_groups(self): return self._groups groups = property(_get_groups) def _get_user_permissions(self): return self._user_permissions user_permissions = property(_get_user_permissions) def get_group_permissions(self, obj=None): return set() def get_all_permissions(self, obj=None): return _user_get_all_permissions(self, obj=obj) def has_perm(self, perm, obj=None): return _user_has_perm(self, perm, obj=obj) def has_perms(self, perm_list, obj=None): for perm in perm_list: if not self.has_perm(perm, obj): return False return True def has_module_perms(self, module): return _user_has_module_perms(self, module) def is_anonymous(self): return True def is_authenticated(self): return False
pwmarcz/django
django/contrib/auth/models.py
Python
bsd-3-clause
17,843
0.001121
from dbmail.providers.microsoft.base import MPNSBase class MPNSRaw(MPNSBase): NOTIFICATION_CLS = 3 TARGET = 'raw' def payload(self, payload): return payload def send(uri, *_, **kwargs): return MPNSRaw().send(uri, kwargs)
LPgenerator/django-db-mailer
dbmail/providers/microsoft/raw.py
Python
gpl-2.0
250
0
# # Copyright 2010 Free Software Foundation, Inc. # # This file was generated by gr_modtool, a tool from the GNU Radio framework # This file is a part of gr-display # # SPDX-License-Identifier: GPL-3.0-or-later # # """ Utilities for extracting text from generated classes. """ from __future__ import unicode_literals def is_string(txt): if isinstance(txt, str): return True try: if isinstance(txt, str): return True except NameError: pass return False def description(obj): if obj is None: return None return description_bit(obj).strip() def description_bit(obj): if hasattr(obj, 'content'): contents = [description_bit(item) for item in obj.content] result = ''.join(contents) elif hasattr(obj, 'content_'): contents = [description_bit(item) for item in obj.content_] result = ''.join(contents) elif hasattr(obj, 'value'): result = description_bit(obj.value) elif is_string(obj): return obj else: raise Exception('Expecting a string or something with content, content_ or value attribute') # If this bit is a paragraph then add one some line breaks. if hasattr(obj, 'name') and obj.name == 'para': result += "\n\n" return result
dl1ksv/gr-display
docs/doxygen/doxyxml/text.py
Python
gpl-3.0
1,297
0.003084
from ..utils.api import api_handler from ..utils.decorators import detect_batch_decorator @detect_batch_decorator def sentiment(text, cloud=None, batch=False, api_key=None, version=None, **kwargs): """ Given input text, returns a scalar estimate of the sentiment of that text. Values are roughly in the range 0 to 1 with 0.5 indicating neutral sentiment. For reference, 0 suggests very negative sentiment and 1 suggests very positive sentiment. Example usage: .. code-block:: python >>> from indicoio import sentiment >>> text = 'Thanks everyone for the birthday wishes!! It was a crazy few days ><' >>> sentiment = sentiment(text) >>> sentiment 0.6946439339979863 :param text: The text to be analyzed. :type text: str or unicode :rtype: Float """ url_params = {"batch": batch, "api_key": api_key, "version": version} return api_handler( text, cloud=cloud, api="sentiment", url_params=url_params, **kwargs )
IndicoDataSolutions/IndicoIo-python
indicoio/text/sentiment.py
Python
mit
1,009
0.003964
"""hicks URL Configuration The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.8/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^$', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') Including another URLconf 1. Add an import: from blog import urls as blog_urls 2. Add a URL to urlpatterns: url(r'^blog/', include(blog_urls)) """ from django.conf import settings from django.conf.urls import include, url from django.contrib import admin from django.views.generic import TemplateView urlpatterns = [ # Toolbar static pages url( # / regex=r'^$', view=TemplateView.as_view(template_name='pages/home.html'), name='home'), url( # /about/ regex=r'^about/$', view=TemplateView.as_view(template_name='pages/about.html'), name='about'), # Django Admin url( # /admin/ regex=r'^admin/', view=include(admin.site.urls)), # django-allauth url( # /accounts/ regex=r'^accounts/', view=include('allauth.urls') ), # hicks_language url( # /lang/ regex=r'^lang/', view=include('hicks.hicks_language.urls', namespace='hicks_language'), ), # hicks_glossary url( # /project/ regex=r'^project/', view=include('hicks.hicks_glossary.urls', namespace='hicks_glossary'), ), ] if settings.DEBUG: urlpatterns += [ url(r'^400/$', 'django.views.defaults.bad_request'), url(r'^403/$', 'django.views.defaults.permission_denied'), url(r'^404/$', 'django.views.defaults.page_not_found'), url(r'^500/$', 'django.views.defaults.server_error'), ]
sgarrad/hicks
config/urls.py
Python
gpl-3.0
1,959
0.001021
# -*- coding: utf-8 -*- """ tests.regression ~~~~~~~~~~~~~~~~~~~~~~~~~~ Tests regressions. :copyright: (c) 2015 by Armin Ronacher. :license: BSD, see LICENSE for more details. """ import gc import sys import threading import pytest from werkzeug.exceptions import NotFound import flask _gc_lock = threading.Lock() class assert_no_leak(object): def __enter__(self): gc.disable() _gc_lock.acquire() loc = flask._request_ctx_stack._local # Force Python to track this dictionary at all times. # This is necessary since Python only starts tracking # dicts if they contain mutable objects. It's a horrible, # horrible hack but makes this kinda testable. loc.__storage__['FOOO'] = [1, 2, 3] gc.collect() self.old_objects = len(gc.get_objects()) def __exit__(self, exc_type, exc_value, tb): gc.collect() new_objects = len(gc.get_objects()) if new_objects > self.old_objects: pytest.fail('Example code leaked') _gc_lock.release() gc.enable() def test_memory_consumption(): app = flask.Flask(__name__) @app.route('/') def index(): return flask.render_template('simple_template.html', whiskey=42) def fire(): with app.test_client() as c: rv = c.get('/') assert rv.status_code == 200 assert rv.data == b'<h1>42</h1>' # Trigger caches fire() # This test only works on CPython 2.7. if sys.version_info >= (2, 7) and \ not hasattr(sys, 'pypy_translation_info'): with assert_no_leak(): for x in range(10): fire() def test_safe_join_toplevel_pardir(): from flask.helpers import safe_join with pytest.raises(NotFound): safe_join('/foo', '..') def test_aborting(): class Foo(Exception): whatever = 42 app = flask.Flask(__name__) app.testing = True @app.errorhandler(Foo) def handle_foo(e): return str(e.whatever) @app.route('/') def index(): raise flask.abort(flask.redirect(flask.url_for('test'))) @app.route('/test') def test(): raise Foo() with app.test_client() as c: rv = c.get('/') assert rv.headers['Location'] == 'http://localhost/test' rv = c.get('/test') assert rv.data == b'42'
dawran6/flask
tests/test_regression.py
Python
bsd-3-clause
2,409
0
#!/usr/bin/python # -*- coding: utf-8 -*- ''' Search Architecture: - Have a list of accounts - Create an "overseer" thread - Search Overseer: - Tracks incoming new location values - Tracks "paused state" - During pause or new location will clears current search queue - Starts search_worker threads - Search Worker Threads each: - Have a unique API login - Listens to the same Queue for areas to scan - Can re-login as needed - Pushes finds to db queue and webhook queue ''' import logging import math import os import sys import traceback import random import time import copy import requests import schedulers import terminalsize import timeit from datetime import datetime from threading import Thread, Lock from queue import Queue, Empty from sets import Set from collections import deque from requests.adapters import HTTPAdapter from requests.packages.urllib3.util.retry import Retry from distutils.version import StrictVersion from pgoapi.utilities import f2i from pgoapi import utilities as util from pgoapi.hash_server import (HashServer, BadHashRequestException, HashingOfflineException) from .models import (parse_map, GymDetails, parse_gyms, MainWorker, WorkerStatus, HashKeys) from .utils import now, clear_dict_response from .transform import get_new_coords, jitter_location from .account import (setup_api, check_login, get_tutorial_state, complete_tutorial, AccountSet, parse_new_timestamp_ms) from .captcha import captcha_overseer_thread, handle_captcha from .proxy import get_new_proxy log = logging.getLogger(__name__) loginDelayLock = Lock() # Thread to handle user input. def switch_status_printer(display_type, current_page, mainlog, loglevel, logmode): # Disable logging of the first handler - the stream handler, and disable # it's output. if (logmode != 'logs'): mainlog.handlers[0].setLevel(logging.CRITICAL) while True: # Wait for the user to press a key. command = raw_input() if command == '': # Switch between logging and display. if display_type[0] != 'logs': # Disable display, enable on screen logging. mainlog.handlers[0].setLevel(loglevel) display_type[0] = 'logs' # If logs are going slowly, sometimes it's hard to tell you # switched. Make it clear. print 'Showing logs...' elif display_type[0] == 'logs': # Enable display, disable on screen logging (except for # critical messages). mainlog.handlers[0].setLevel(logging.CRITICAL) display_type[0] = 'workers' elif command.isdigit(): current_page[0] = int(command) mainlog.handlers[0].setLevel(logging.CRITICAL) display_type[0] = 'workers' elif command.lower() == 'f': mainlog.handlers[0].setLevel(logging.CRITICAL) display_type[0] = 'failedaccounts' elif command.lower() == 'h': mainlog.handlers[0].setLevel(logging.CRITICAL) display_type[0] = 'hashstatus' # Thread to print out the status of each worker. def status_printer(threadStatus, search_items_queue_array, db_updates_queue, wh_queue, account_queue, account_failures, account_captchas, logmode, hash_key, key_scheduler): if (logmode == 'logs'): display_type = ['logs'] else: display_type = ['workers'] current_page = [1] # Grab current log / level. mainlog = logging.getLogger() loglevel = mainlog.getEffectiveLevel() # Start another thread to get user input. t = Thread(target=switch_status_printer, name='switch_status_printer', args=(display_type, current_page, mainlog, loglevel, logmode)) t.daemon = True t.start() while True: time.sleep(1) if display_type[0] == 'logs': # In log display mode, we don't want to show anything. continue # Create a list to hold all the status lines, so they can be printed # all at once to reduce flicker. status_text = [] if display_type[0] == 'workers': # Get the terminal size. width, height = terminalsize.get_terminal_size() # Queue and overseer take 2 lines. Switch message takes up 2 # lines. Remove an extra 2 for things like screen status lines. usable_height = height - 6 # Prevent people running terminals only 6 lines high from getting a # divide by zero. if usable_height < 1: usable_height = 1 # Print the queue length. search_items_queue_size = 0 for i in range(0, len(search_items_queue_array)): search_items_queue_size += search_items_queue_array[i].qsize() skip_total = threadStatus['Overseer']['skip_total'] status_text.append(( 'Queues: {} search items, {} db updates, {} webhook. ' + 'Total skipped items: {}. Spare accounts available: {}. ' + 'Accounts on hold: {}. Accounts with captcha: {}').format( search_items_queue_size, db_updates_queue.qsize(), wh_queue.qsize(), skip_total, account_queue.qsize(), len(account_failures), len(account_captchas))) # Print status of overseer. status_text.append('{} Overseer: {}'.format( threadStatus['Overseer']['scheduler'], threadStatus['Overseer']['message'])) # Calculate the total number of pages. Subtracting for the # overseer. overseer_line_count = ( threadStatus['Overseer']['message'].count('\n')) total_pages = math.ceil( (len(threadStatus) - 1 - overseer_line_count) / float(usable_height)) # Prevent moving outside the valid range of pages. if current_page[0] > total_pages: current_page[0] = total_pages if current_page[0] < 1: current_page[0] = 1 # Calculate which lines to print. start_line = usable_height * (current_page[0] - 1) end_line = start_line + usable_height current_line = 1 # Find the longest username and proxy. userlen = 4 proxylen = 5 for item in threadStatus: if threadStatus[item]['type'] == 'Worker': userlen = max(userlen, len(threadStatus[item]['username'])) if 'proxy_display' in threadStatus[item]: proxylen = max(proxylen, len( str(threadStatus[item]['proxy_display']))) # How pretty. status = '{:10} | {:5} | {:' + str(userlen) + '} | {:' + str( proxylen) + '} | {:7} | {:6} | {:5} | {:7} | {:8} | {:10}' # Print the worker status. status_text.append(status.format('Worker ID', 'Start', 'User', 'Proxy', 'Success', 'Failed', 'Empty', 'Skipped', 'Captchas', 'Message')) for item in sorted(threadStatus): if(threadStatus[item]['type'] == 'Worker'): current_line += 1 # Skip over items that don't belong on this page. if current_line < start_line: continue if current_line > end_line: break status_text.append(status.format( item, time.strftime('%H:%M', time.localtime( threadStatus[item]['starttime'])), threadStatus[item]['username'], threadStatus[item]['proxy_display'], threadStatus[item]['success'], threadStatus[item]['fail'], threadStatus[item]['noitems'], threadStatus[item]['skip'], threadStatus[item]['captcha'], threadStatus[item]['message'])) elif display_type[0] == 'failedaccounts': status_text.append('-----------------------------------------') status_text.append('Accounts on hold:') status_text.append('-----------------------------------------') # Find the longest account name. userlen = 4 for account in account_failures: userlen = max(userlen, len(account['account']['username'])) status = '{:' + str(userlen) + '} | {:10} | {:20}' status_text.append(status.format('User', 'Hold Time', 'Reason')) for account in account_failures: status_text.append(status.format( account['account']['username'], time.strftime('%H:%M:%S', time.localtime(account['last_fail_time'])), account['reason'])) elif display_type[0] == 'hashstatus': status_text.append( '----------------------------------------------------------') status_text.append('Hash key status:') status_text.append( '----------------------------------------------------------') status = '{:21} | {:9} | {:9} | {:9}' status_text.append(status.format('Key', 'Remaining', 'Maximum', 'Peak')) if hash_key is not None: for key in hash_key: key_instance = key_scheduler.keys[key] key_text = key if key_scheduler.current() == key: key_text += '*' status_text.append(status.format( key_text, key_instance['remaining'], key_instance['maximum'], key_instance['peak'])) # Print the status_text for the current screen. status_text.append(( 'Page {}/{}. Page number to switch pages. F to show on hold ' + 'accounts. H to show hash status. <ENTER> alone to switch ' + 'between status and log view').format(current_page[0], total_pages)) # Clear the screen. os.system('cls' if os.name == 'nt' else 'clear') # Print status. print '\n'.join(status_text) # The account recycler monitors failed accounts and places them back in the # account queue 2 hours after they failed. # This allows accounts that were soft banned to be retried after giving # them a chance to cool down. def account_recycler(args, accounts_queue, account_failures): while True: # Run once a minute. time.sleep(60) log.info('Account recycler running. Checking status of %d accounts.', len(account_failures)) # Create a new copy of the failure list to search through, so we can # iterate through it without it changing. failed_temp = list(account_failures) # Search through the list for any item that last failed before # -ari/--account-rest-interval seconds. ok_time = now() - args.account_rest_interval for a in failed_temp: if a['last_fail_time'] <= ok_time: # Remove the account from the real list, and add to the account # queue. log.info('Account {} returning to active duty.'.format( a['account']['username'])) account_failures.remove(a) accounts_queue.put(a['account']) else: if 'notified' not in a: log.info(( 'Account {} needs to cool off for {} minutes due ' + 'to {}.').format( a['account']['username'], round((a['last_fail_time'] - ok_time) / 60, 0), a['reason'])) a['notified'] = True def worker_status_db_thread(threads_status, name, db_updates_queue): while True: workers = {} overseer = None for status in threads_status.values(): if status['type'] == 'Overseer': overseer = { 'worker_name': name, 'message': status['message'], 'method': status['scheduler'], 'last_modified': datetime.utcnow(), 'accounts_working': status['active_accounts'], 'accounts_captcha': status['accounts_captcha'], 'accounts_failed': status['accounts_failed'] } elif status['type'] == 'Worker': workers[status['username']] = WorkerStatus.db_format( status, name) if overseer is not None: db_updates_queue.put((MainWorker, {0: overseer})) db_updates_queue.put((WorkerStatus, workers)) time.sleep(3) # The main search loop that keeps an eye on the over all process. def search_overseer_thread(args, new_location_queue, pause_bit, heartb, db_updates_queue, wh_queue): log.info('Search overseer starting...') search_items_queue_array = [] scheduler_array = [] account_queue = Queue() account_sets = AccountSet(args.hlvl_kph) threadStatus = {} key_scheduler = None api_check_time = 0 hashkeys_last_upsert = timeit.default_timer() hashkeys_upsert_min_delay = 5.0 ''' Create a queue of accounts for workers to pull from. When a worker has failed too many times, it can get a new account from the queue and reinitialize the API. Workers should return accounts to the queue so they can be tried again later, but must wait a bit before doing do so to prevent accounts from being cycled through too quickly. ''' for i, account in enumerate(args.accounts): account_queue.put(account) ''' Create sets of special case accounts. Currently limited to L30+ IV/CP scanning. ''' account_sets.create_set('30', args.accounts_L30) # Debug. log.info('Added %s accounts to the L30 pool.', len(args.accounts_L30)) # Create a list for failed accounts. account_failures = [] # Create a double-ended queue for captcha'd accounts account_captchas = deque() threadStatus['Overseer'] = { 'message': 'Initializing', 'type': 'Overseer', 'starttime': now(), 'accounts_captcha': 0, 'accounts_failed': 0, 'active_accounts': 0, 'skip_total': 0, 'captcha_total': 0, 'success_total': 0, 'fail_total': 0, 'empty_total': 0, 'scheduler': args.scheduler, 'scheduler_status': {'tth_found': 0} } # Create the key scheduler. if args.hash_key: log.info('Enabling hashing key scheduler...') key_scheduler = schedulers.KeyScheduler(args.hash_key, db_updates_queue) if(args.print_status): log.info('Starting status printer thread...') t = Thread(target=status_printer, name='status_printer', args=(threadStatus, search_items_queue_array, db_updates_queue, wh_queue, account_queue, account_failures, account_captchas, args.print_status, args.hash_key, key_scheduler)) t.daemon = True t.start() # Create account recycler thread. log.info('Starting account recycler thread...') t = Thread(target=account_recycler, name='account-recycler', args=(args, account_queue, account_failures)) t.daemon = True t.start() # Create captcha overseer thread. if args.captcha_solving: log.info('Starting captcha overseer thread...') t = Thread(target=captcha_overseer_thread, name='captcha-overseer', args=(args, account_queue, account_captchas, key_scheduler, wh_queue)) t.daemon = True t.start() if args.status_name is not None: log.info('Starting status database thread...') t = Thread(target=worker_status_db_thread, name='status_worker_db', args=(threadStatus, args.status_name, db_updates_queue)) t.daemon = True t.start() # Create specified number of search_worker_thread. log.info('Starting search worker threads...') log.info('Configured scheduler is %s.', args.scheduler) for i in range(0, args.workers): log.debug('Starting search worker thread %d...', i) if i == 0 or (args.beehive and i % args.workers_per_hive == 0): search_items_queue = Queue() # Create the appropriate type of scheduler to handle the search # queue. scheduler = schedulers.SchedulerFactory.get_scheduler( args.scheduler, [search_items_queue], threadStatus, args) scheduler_array.append(scheduler) search_items_queue_array.append(search_items_queue) # Set proxy for each worker, using round robin. proxy_display = 'No' proxy_url = False # Will be assigned inside a search thread. workerId = 'Worker {:03}'.format(i) threadStatus[workerId] = { 'type': 'Worker', 'message': 'Creating thread...', 'success': 0, 'fail': 0, 'noitems': 0, 'skip': 0, 'captcha': 0, 'username': '', 'proxy_display': proxy_display, 'proxy_url': proxy_url, } t = Thread(target=search_worker_thread, name='search-worker-{}'.format(i), args=(args, account_queue, account_sets, account_failures, account_captchas, search_items_queue, pause_bit, threadStatus[workerId], db_updates_queue, wh_queue, scheduler, key_scheduler)) t.daemon = True t.start() if not args.no_version_check: log.info('Enabling new API force Watchdog.') # A place to track the current location. current_location = False # Keep track of the last status for accounts so we can calculate # what have changed since the last check last_account_status = {} stats_timer = 0 # The real work starts here but will halt on pause_bit.set(). while True: if (args.hash_key is not None and (hashkeys_last_upsert + hashkeys_upsert_min_delay) <= timeit.default_timer()): upsertKeys(args.hash_key, key_scheduler, db_updates_queue) hashkeys_last_upsert = timeit.default_timer() odt_triggered = (args.on_demand_timeout > 0 and (now() - args.on_demand_timeout) > heartb[0]) if odt_triggered: pause_bit.set() log.info('Searching paused due to inactivity...') # Wait here while scanning is paused. while pause_bit.is_set(): for i in range(0, len(scheduler_array)): scheduler_array[i].scanning_paused() # API Watchdog - Continue to check API version. if not args.no_version_check and not odt_triggered: api_check_time = check_forced_version( args, api_check_time, pause_bit) time.sleep(1) # If a new location has been passed to us, get the most recent one. if not new_location_queue.empty(): log.info('New location caught, moving search grid.') try: while True: current_location = new_location_queue.get_nowait() except Empty: pass step_distance = 0.45 if args.no_pokemon else 0.07 locations = generate_hive_locations( current_location, step_distance, args.step_limit, len(scheduler_array)) for i in range(0, len(scheduler_array)): scheduler_array[i].location_changed(locations[i], db_updates_queue) # If there are no search_items_queue either the loop has finished or # it's been cleared above. Either way, time to fill it back up. for i in range(0, len(scheduler_array)): if scheduler_array[i].time_to_refresh_queue(): threadStatus['Overseer']['message'] = ( 'Search queue {} empty, scheduling ' + 'more items to scan.').format(i) log.debug( 'Search queue %d empty, scheduling more items to scan.', i) try: # Can't have the scheduler die because of a DB deadlock. scheduler_array[i].schedule() except Exception as e: log.error( 'Schedule creation had an Exception: {}.'.format( repr(e))) traceback.print_exc(file=sys.stdout) time.sleep(10) else: threadStatus['Overseer']['message'] = scheduler_array[ i].get_overseer_message() # Let's update the total stats and add that info to message # Added exception handler as dict items change try: update_total_stats(threadStatus, last_account_status) except Exception as e: log.error( 'Update total stats had an Exception: {}.'.format( repr(e))) traceback.print_exc(file=sys.stdout) time.sleep(10) threadStatus['Overseer']['message'] += '\n' + get_stats_message( threadStatus) # If enabled, display statistics information into logs on a # periodic basis. if args.stats_log_timer: stats_timer += 1 if stats_timer == args.stats_log_timer: log.info(get_stats_message(threadStatus)) stats_timer = 0 # Update Overseer statistics threadStatus['Overseer']['accounts_failed'] = len(account_failures) threadStatus['Overseer']['accounts_captcha'] = len(account_captchas) # Send webhook updates when scheduler status changes. if args.webhook_scheduler_updates: wh_status_update(args, threadStatus['Overseer'], wh_queue, scheduler_array[0]) # API Watchdog - Check if Niantic forces a new API. if not args.no_version_check and not odt_triggered: api_check_time = check_forced_version( args, api_check_time, pause_bit) # Now we just give a little pause here. time.sleep(1) def get_scheduler_tth_found_pct(scheduler): tth_found_pct = getattr(scheduler, 'tth_found', 0) if tth_found_pct > 0: # Avoid division by zero. Keep 0.0 default for consistency. active_sp = max(getattr(scheduler, 'active_sp', 0.0), 1.0) tth_found_pct = tth_found_pct * 100.0 / float(active_sp) return tth_found_pct def wh_status_update(args, status, wh_queue, scheduler): scheduler_name = status['scheduler'] if args.speed_scan: tth_found = get_scheduler_tth_found_pct(scheduler) spawns_found = getattr(scheduler, 'spawns_found', 0) if (tth_found - status['scheduler_status']['tth_found']) > 0.01: log.debug('Scheduler update is due, sending webhook message.') wh_queue.put(('scheduler', {'name': scheduler_name, 'instance': args.status_name, 'tth_found': tth_found, 'spawns_found': spawns_found})) status['scheduler_status']['tth_found'] = tth_found def get_stats_message(threadStatus): overseer = threadStatus['Overseer'] starttime = overseer['starttime'] elapsed = now() - starttime # Just to prevent division by 0 errors, when needed # set elapsed to 1 millisecond if elapsed == 0: elapsed = 1 sph = overseer['success_total'] * 3600.0 / elapsed fph = overseer['fail_total'] * 3600.0 / elapsed eph = overseer['empty_total'] * 3600.0 / elapsed skph = overseer['skip_total'] * 3600.0 / elapsed cph = overseer['captcha_total'] * 3600.0 / elapsed ccost = cph * 0.00299 cmonth = ccost * 730 message = ('Total active: {} | Success: {} ({:.1f}/hr) | ' + 'Fails: {} ({:.1f}/hr) | Empties: {} ({:.1f}/hr) | ' + 'Skips {} ({:.1f}/hr) | ' + 'Captchas: {} ({:.1f}/hr)|${:.5f}/hr|${:.3f}/mo').format( overseer['active_accounts'], overseer['success_total'], sph, overseer['fail_total'], fph, overseer['empty_total'], eph, overseer['skip_total'], skph, overseer['captcha_total'], cph, ccost, cmonth) return message def update_total_stats(threadStatus, last_account_status): overseer = threadStatus['Overseer'] # Calculate totals. usercount = 0 current_accounts = Set() for tstatus in threadStatus.itervalues(): if tstatus.get('type', '') == 'Worker': usercount += 1 username = tstatus.get('username', '') current_accounts.add(username) last_status = last_account_status.get(username, {}) overseer['skip_total'] += stat_delta(tstatus, last_status, 'skip') overseer[ 'captcha_total'] += stat_delta(tstatus, last_status, 'captcha') overseer[ 'empty_total'] += stat_delta(tstatus, last_status, 'noitems') overseer['fail_total'] += stat_delta(tstatus, last_status, 'fail') overseer[ 'success_total'] += stat_delta(tstatus, last_status, 'success') last_account_status[username] = copy.deepcopy(tstatus) overseer['active_accounts'] = usercount # Remove last status for accounts that workers # are not using anymore for username in last_account_status.keys(): if username not in current_accounts: del last_account_status[username] # Generates the list of locations to scan. def generate_hive_locations(current_location, step_distance, step_limit, hive_count): NORTH = 0 EAST = 90 SOUTH = 180 WEST = 270 xdist = math.sqrt(3) * step_distance # Distance between column centers. ydist = 3 * (step_distance / 2) # Distance between row centers. results = [] results.append((current_location[0], current_location[1], 0)) loc = current_location ring = 1 while len(results) < hive_count: loc = get_new_coords(loc, ydist * (step_limit - 1), NORTH) loc = get_new_coords(loc, xdist * (1.5 * step_limit - 0.5), EAST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist * step_limit, NORTH) loc = get_new_coords(loc, xdist * (1.5 * step_limit - 1), WEST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist * (step_limit - 1), SOUTH) loc = get_new_coords(loc, xdist * (1.5 * step_limit - 0.5), WEST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist * (2 * step_limit - 1), SOUTH) loc = get_new_coords(loc, xdist * 0.5, WEST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist * (step_limit), SOUTH) loc = get_new_coords(loc, xdist * (1.5 * step_limit - 1), EAST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist * (step_limit - 1), NORTH) loc = get_new_coords(loc, xdist * (1.5 * step_limit - 0.5), EAST) results.append((loc[0], loc[1], 0)) # Back to start. for i in range(ring - 1): loc = get_new_coords(loc, ydist * (2 * step_limit - 1), NORTH) loc = get_new_coords(loc, xdist * 0.5, EAST) results.append((loc[0], loc[1], 0)) loc = get_new_coords(loc, ydist * (2 * step_limit - 1), NORTH) loc = get_new_coords(loc, xdist * 0.5, EAST) ring += 1 return results def search_worker_thread(args, account_queue, account_sets, account_failures, account_captchas, search_items_queue, pause_bit, status, dbq, whq, scheduler, key_scheduler): log.debug('Search worker thread starting...') # The outer forever loop restarts only when the inner one is # intentionally exited - which should only be done when the worker # is failing too often, and probably banned. # This reinitializes the API and grabs a new account from the queue. while True: try: # Force storing of previous worker info to keep consistency. if 'starttime' in status: dbq.put((WorkerStatus, {0: WorkerStatus.db_format(status)})) status['starttime'] = now() # Track per loop. first_login = True # Make sure the scheduler is done for valid locations. while not scheduler.ready: time.sleep(1) status['message'] = ('Waiting to get new account from the' + ' queue...') log.info(status['message']) # Get an account. account = account_queue.get() status.update(WorkerStatus.get_worker( account['username'], scheduler.scan_location)) status['message'] = 'Switching to account {}.'.format( account['username']) log.info(status['message']) # New lease of life right here. status['fail'] = 0 status['success'] = 0 status['noitems'] = 0 status['skip'] = 0 status['captcha'] = 0 stagger_thread(args) # Sleep when consecutive_fails reaches max_failures, overall fails # for stat purposes. consecutive_fails = 0 # Sleep when consecutive_noitems reaches max_empty, overall noitems # for stat purposes. consecutive_noitems = 0 api = setup_api(args, status, account) # The forever loop for the searches. while True: while pause_bit.is_set(): status['message'] = 'Scanning paused.' time.sleep(2) # If this account has been messing up too hard, let it rest. if ((args.max_failures > 0) and (consecutive_fails >= args.max_failures)): status['message'] = ( 'Account {} failed more than {} scans; possibly bad ' + 'account. Switching accounts...').format( account['username'], args.max_failures) log.warning(status['message']) account_failures.append({'account': account, 'last_fail_time': now(), 'reason': 'failures'}) # Exit this loop to get a new account and have the API # recreated. break # If this account has not found anything for too long, let it # rest. if ((args.max_empty > 0) and (consecutive_noitems >= args.max_empty)): status['message'] = ( 'Account {} returned empty scan for more than {} ' + 'scans; possibly ip is banned. Switching ' + 'accounts...').format(account['username'], args.max_empty) log.warning(status['message']) account_failures.append({'account': account, 'last_fail_time': now(), 'reason': 'empty scans'}) # Exit this loop to get a new account and have the API # recreated. break # If used proxy disappears from "live list" after background # checking - switch account but do not freeze it (it's not an # account failure). if args.proxy and status['proxy_url'] not in args.proxy: status['message'] = ( 'Account {} proxy {} is not in a live list any ' + 'more. Switching accounts...').format( account['username'], status['proxy_url']) log.warning(status['message']) # Experimental, nobody did this before. account_queue.put(account) # Exit this loop to get a new account and have the API # recreated. break # If this account has been running too long, let it rest. if (args.account_search_interval is not None): if (status['starttime'] <= (now() - args.account_search_interval)): status['message'] = ( 'Account {} is being rotated out to rest.'.format( account['username'])) log.info(status['message']) account_failures.append({'account': account, 'last_fail_time': now(), 'reason': 'rest interval'}) break # Grab the next thing to search (when available). step, step_location, appears, leaves, messages, wait = ( scheduler.next_item(status)) status['message'] = messages['wait'] # The next_item will return the value telling us how long # to sleep. This way the status can be updated time.sleep(wait) # Using step as a flag for no valid next location returned. if step == -1: time.sleep(scheduler.delay(status['last_scan_date'])) continue # Too soon? # Adding a 10 second grace period. if appears and now() < appears + 10: first_loop = True paused = False while now() < appears + 10: if pause_bit.is_set(): paused = True break # Why can't python just have `break 2`... status['message'] = messages['early'] if first_loop: log.info(status['message']) first_loop = False time.sleep(1) if paused: scheduler.task_done(status) continue # Too late? if leaves and now() > (leaves - args.min_seconds_left): scheduler.task_done(status) status['skip'] += 1 status['message'] = messages['late'] log.info(status['message']) # No sleep here; we've not done anything worth sleeping # for. Plus we clearly need to catch up! continue status['message'] = messages['search'] log.debug(status['message']) # Let the api know where we intend to be for this loop. # Doing this before check_login so it does not also have # to be done when the auth token is refreshed. api.set_position(*step_location) if args.hash_key: key = key_scheduler.next() log.debug('Using key {} for this scan.'.format(key)) api.activate_hash_server(key) # Ok, let's get started -- check our login status. status['message'] = 'Logging in...' check_login(args, account, api, step_location, status['proxy_url']) # Only run this when it's the account's first login, after # check_login(). if first_login: first_login = False # Check tutorial completion. if args.complete_tutorial: tutorial_state = get_tutorial_state(args, api, account) if not all(x in tutorial_state for x in (0, 1, 3, 4, 7)): log.info('Completing tutorial steps for %s.', account['username']) complete_tutorial(args, api, account, tutorial_state) else: log.info('Account %s already completed tutorial.', account['username']) # Putting this message after the check_login so the messages # aren't out of order. status['message'] = messages['search'] log.info(status['message']) # Make the actual request. scan_date = datetime.utcnow() response_dict = map_request(api, account, step_location, args.no_jitter) status['last_scan_date'] = datetime.utcnow() # Record the time and the place that the worker made the # request. status['latitude'] = step_location[0] status['longitude'] = step_location[1] dbq.put((WorkerStatus, {0: WorkerStatus.db_format(status)})) # Nothing back. Mark it up, sleep, carry on. if not response_dict: status['fail'] += 1 consecutive_fails += 1 status['message'] = messages['invalid'] log.error(status['message']) time.sleep(scheduler.delay(status['last_scan_date'])) continue # Got the response, check for captcha, parse it out, then send # todo's to db/wh queues. try: captcha = handle_captcha(args, status, api, account, account_failures, account_captchas, whq, response_dict, step_location) if captcha is not None and captcha: # Make another request for the same location # since the previous one was captcha'd. scan_date = datetime.utcnow() response_dict = map_request(api, account, step_location, args.no_jitter) elif captcha is not None: account_queue.task_done() time.sleep(3) break parsed = parse_map(args, response_dict, step_location, dbq, whq, key_scheduler, api, status, scan_date, account, account_sets) del response_dict scheduler.task_done(status, parsed) if parsed['count'] > 0: status['success'] += 1 consecutive_noitems = 0 else: status['noitems'] += 1 consecutive_noitems += 1 consecutive_fails = 0 status['message'] = ('Search at {:6f},{:6f} completed ' + 'with {} finds.').format( step_location[0], step_location[1], parsed['count']) log.debug(status['message']) except Exception as e: parsed = False status['fail'] += 1 consecutive_fails += 1 # consecutive_noitems = 0 - I propose to leave noitems # counter in case of error. status['message'] = ('Map parse failed at {:6f},{:6f}, ' + 'abandoning location. {} may be ' + 'banned.').format(step_location[0], step_location[1], account['username']) log.exception('{}. Exception message: {}'.format( status['message'], repr(e))) if response_dict is not None: del response_dict # Get detailed information about gyms. if args.gym_info and parsed: # Build a list of gyms to update. gyms_to_update = {} for gym in parsed['gyms'].values(): # Can only get gym details within 1km of our position. distance = calc_distance( step_location, [gym['latitude'], gym['longitude']]) if distance < 1.0: # Check if we already have details on this gym. # Get them if not. try: record = GymDetails.get(gym_id=gym['gym_id']) except GymDetails.DoesNotExist as e: gyms_to_update[gym['gym_id']] = gym continue # If we have a record of this gym already, check if # the gym has been updated since our last update. if record.last_scanned < gym['last_modified']: gyms_to_update[gym['gym_id']] = gym continue else: log.debug( ('Skipping update of gym @ %f/%f, ' + 'up to date.'), gym['latitude'], gym['longitude']) continue else: log.debug( ('Skipping update of gym @ %f/%f, too far ' + 'away from our location at %f/%f (%fkm).'), gym['latitude'], gym['longitude'], step_location[0], step_location[1], distance) if len(gyms_to_update): gym_responses = {} current_gym = 1 status['message'] = ( 'Updating {} gyms for location {},{}...').format( len(gyms_to_update), step_location[0], step_location[1]) log.debug(status['message']) for gym in gyms_to_update.values(): status['message'] = ( 'Getting details for gym {} of {} for ' + 'location {:6f},{:6f}...').format( current_gym, len(gyms_to_update), step_location[0], step_location[1]) time.sleep(random.random() + 2) response = gym_request(api, account, step_location, gym, args.api_version) # Make sure the gym was in range. (Sometimes the # API gets cranky about gyms that are ALMOST 1km # away.) if response: if response['responses'][ 'GYM_GET_INFO']['result'] == 2: log.warning( ('Gym @ %f/%f is out of range (%dkm),' + ' skipping.'), gym['latitude'], gym['longitude'], distance) else: gym_responses[gym['gym_id']] = response[ 'responses']['GYM_GET_INFO'] del response # Increment which gym we're on for status messages. current_gym += 1 status['message'] = ( 'Processing details of {} gyms for location ' + '{:6f},{:6f}...').format(len(gyms_to_update), step_location[0], step_location[1]) log.debug(status['message']) if gym_responses: parse_gyms(args, gym_responses, whq, dbq) del gym_responses # Update hashing key stats in the database based on the values # reported back by the hashing server. if args.hash_key: key = HashServer.status.get('token', None) key_instance = key_scheduler.keys[key] key_instance['remaining'] = HashServer.status.get( 'remaining', 0) key_instance['maximum'] = ( HashServer.status.get('maximum', 0)) usage = ( key_instance['maximum'] - key_instance['remaining']) if key_instance['peak'] < usage: key_instance['peak'] = usage if key_instance['expires'] is None: expires = HashServer.status.get( 'expiration', None) if expires is not None: expires = datetime.utcfromtimestamp(expires) key_instance['expires'] = expires key_instance['last_updated'] = datetime.utcnow() log.debug('Hash key %s has %s/%s RPM left.', key, key_instance['remaining'], key_instance['maximum']) # Delay the desired amount after "scan" completion. delay = scheduler.delay(status['last_scan_date']) status['message'] += ' Sleeping {}s until {}.'.format( delay, time.strftime( '%H:%M:%S', time.localtime(time.time() + args.scan_delay))) log.info(status['message']) time.sleep(delay) # Catch any process exceptions, log them, and continue the thread. except Exception as e: log.error(( 'Exception in search_worker under account {} Exception ' + 'message: {}.').format(account['username'], repr(e))) status['message'] = ( 'Exception in search_worker using account {}. Restarting ' + 'with fresh account. See logs for details.').format( account['username']) traceback.print_exc(file=sys.stdout) account_failures.append({'account': account, 'last_fail_time': now(), 'reason': 'exception'}) time.sleep(args.scan_delay) def upsertKeys(keys, key_scheduler, db_updates_queue): # Prepare hashing keys to be sent to the db. But only # sent latest updates of the 'peak' value per key. hashkeys = {} for key in keys: key_instance = key_scheduler.keys[key] hashkeys[key] = key_instance hashkeys[key]['key'] = key hashkeys[key]['peak'] = max(key_instance['peak'], HashKeys.getStoredPeak(key)) db_updates_queue.put((HashKeys, hashkeys)) def map_request(api, account, position, no_jitter=False): # Create scan_location to send to the api based off of position, because # tuples aren't mutable. if no_jitter: # Just use the original coordinates. scan_location = position else: # Jitter it, just a little bit. scan_location = jitter_location(position) log.debug('Jittered to: %f/%f/%f', scan_location[0], scan_location[1], scan_location[2]) try: cell_ids = util.get_cell_ids(scan_location[0], scan_location[1]) timestamps = [0, ] * len(cell_ids) req = api.create_request() req.get_map_objects(latitude=f2i(scan_location[0]), longitude=f2i(scan_location[1]), since_timestamp_ms=timestamps, cell_id=cell_ids) req.check_challenge() req.get_hatched_eggs() req.get_inventory(last_timestamp_ms=account['last_timestamp_ms']) req.check_awarded_badges() req.get_buddy_walked() req.get_inbox(is_history=True) response = req.call() response = clear_dict_response(response, True) parse_new_timestamp_ms(account, response) return response except HashingOfflineException as e: log.error('Hashing server is unreachable, it might be offline.') except BadHashRequestException as e: log.error('Invalid or expired hashing key: %s.', api._hash_server_token) except Exception as e: log.exception('Exception while downloading map: %s', repr(e)) return False def gym_request(api, account, position, gym, api_version): try: log.info('Getting details for gym @ %f/%f (%fkm away)', gym['latitude'], gym['longitude'], calc_distance(position, [gym['latitude'], gym['longitude']])) req = api.create_request() req.gym_get_info( gym_id=gym['gym_id'], player_lat_degrees=f2i(position[0]), player_lng_degrees=f2i(position[1]), gym_lat_degrees=gym['latitude'], gym_lng_degrees=gym['longitude']) req.check_challenge() req.get_hatched_eggs() req.get_inventory(last_timestamp_ms=account['last_timestamp_ms']) req.check_awarded_badges() req.get_buddy_walked() req.get_inbox(is_history=True) response = req.call() parse_new_timestamp_ms(account, response) response = clear_dict_response(response) return response except Exception as e: log.exception('Exception while downloading gym details: %s.', repr(e)) return False def calc_distance(pos1, pos2): R = 6378.1 # KM radius of the earth. dLat = math.radians(pos1[0] - pos2[0]) dLon = math.radians(pos1[1] - pos2[1]) a = math.sin(dLat / 2) * math.sin(dLat / 2) + \ math.cos(math.radians(pos1[0])) * math.cos(math.radians(pos2[0])) * \ math.sin(dLon / 2) * math.sin(dLon / 2) c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a)) d = R * c return d # Delay each thread start time so that logins occur after delay. def stagger_thread(args): loginDelayLock.acquire() delay = args.login_delay + ((random.random() - .5) / 2) log.debug('Delaying thread startup for %.2f seconds', delay) time.sleep(delay) loginDelayLock.release() # The delta from last stat to current stat def stat_delta(current_status, last_status, stat_name): return current_status.get(stat_name, 0) - last_status.get(stat_name, 0) def check_forced_version(args, api_check_time, pause_bit): if int(time.time()) > api_check_time: log.debug("Checking forced API version.") api_check_time = int(time.time()) + args.version_check_interval forced_api = get_api_version(args) if not forced_api: # Couldn't retrieve API version. Pause scanning. pause_bit.set() log.warning('Forced API check got no or invalid response. ' + 'Possible bad proxy.') log.warning('Scanner paused due to failed API check.') return api_check_time # Got a response let's compare version numbers. try: if StrictVersion(args.api_version) < StrictVersion(forced_api): # Installed API version is lower. Pause scanning. pause_bit.set() log.warning('Started with API: %s, ' + 'Niantic forced to API: %s', args.api_version, forced_api) log.warning('Scanner paused due to forced Niantic API update.') else: # API check was successful and # installed API version is newer or equal forced API. # Continue scanning. log.debug("API check was successful. Continue scanning.") pause_bit.clear() except ValueError as e: # Unknown version format. Pause scanning as well. pause_bit.set() log.warning('Niantic forced unknown API version format: %s.', forced_api) log.warning('Scanner paused due to unknown API version format.') except Exception as e: # Something else happened. Pause scanning as well. pause_bit.set() log.warning('Unknown error on API version comparison: %s.', repr(e)) log.warning('Scanner paused due to unknown API check error.') return api_check_time def get_api_version(args): """Retrieve forced API version by Niantic Args: args: Command line arguments Returns: API version string. False if request failed. """ proxies = {} if args.proxy: num, proxy = get_new_proxy(args) proxies = { 'http': proxy, 'https': proxy } try: s = requests.Session() s.mount('https://', HTTPAdapter(max_retries=Retry(total=3, backoff_factor=0.5, status_forcelist=[500, 502, 503, 504]))) r = s.get( 'https://pgorelease.nianticlabs.com/plfe/version', proxies=proxies, verify=False, timeout=5) return r.text[2:] if r.status_code == requests.codes.ok else False except Exception as e: log.warning('error on API check: %s', repr(e)) return False
mpw1337/RocketMap
pogom/search.py
Python
agpl-3.0
56,889
0
#!/usr/bin/env python3 # Copyright (c) 2012-2017 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. ''' Extract _("...") strings for translation and convert to Qt stringdefs so that they can be picked up by Qt linguist. ''' from subprocess import Popen, PIPE import operator import os import sys OUT_CPP = "qt/bitcoinstrings.cpp" EMPTY = ['""'] def parse_po(text): """ Parse 'po' format produced by xgettext. Return a list of (msgid,msgstr) tuples. """ messages = [] msgid = [] msgstr = [] in_msgid = False in_msgstr = False for line in text.split('\n'): line = line.rstrip('\r') if line.startswith('msgid '): if in_msgstr: messages.append((msgid, msgstr)) in_msgstr = False # message start in_msgid = True msgid = [line[6:]] elif line.startswith('msgstr '): in_msgid = False in_msgstr = True msgstr = [line[7:]] elif line.startswith('"'): if in_msgid: msgid.append(line) if in_msgstr: msgstr.append(line) if in_msgstr: messages.append((msgid, msgstr)) return messages files = sys.argv[1:] # xgettext -n --keyword=_ $FILES XGETTEXT = os.getenv('XGETTEXT', 'xgettext') if not XGETTEXT: print( 'Cannot extract strings: xgettext utility is not installed or not configured.', file=sys.stderr) print('Please install package "gettext" and re-run \'./configure\'.', file=sys.stderr) sys.exit(1) child = Popen([XGETTEXT, '--output=-', '-n', '--keyword=_'] + files, stdout=PIPE) (out, err) = child.communicate() messages = parse_po(out.decode('utf-8')) f = open(OUT_CPP, 'w', encoding="utf8") f.write(""" #include <QtGlobal> // Automatically generated by extract_strings_qt.py #ifdef __GNUC__ #define UNUSED __attribute__((unused)) #else #define UNUSED #endif """) f.write('static const char UNUSED *bitcoin_strings[] = {\n') f.write('QT_TRANSLATE_NOOP("bitcoin-core", "{}"),\n'.format(os.getenv('PACKAGE_NAME'),)) f.write('QT_TRANSLATE_NOOP("bitcoin-core", "{}"),\n'.format(os.getenv('COPYRIGHT_HOLDERS'),)) if os.getenv('COPYRIGHT_HOLDERS_SUBSTITUTION') != os.getenv('PACKAGE_NAME'): f.write('QT_TRANSLATE_NOOP("bitcoin-core", "{}"),\n'.format( os.getenv('COPYRIGHT_HOLDERS_SUBSTITUTION'),)) messages.sort(key=operator.itemgetter(0)) for (msgid, msgstr) in messages: if msgid != EMPTY: f.write('QT_TRANSLATE_NOOP("bitcoin-core", {}),\n'.format('\n'.join(msgid))) f.write('};\n') f.close()
ftrader-bitcoinabc/bitcoin-abc
share/qt/extract_strings_qt.py
Python
mit
2,747
0.001456
#!/usr/bin/env python # coding: utf-8 # Binary with Spots # ============================ # # Setup # ----------------------------- # Let's first make sure we have the latest version of PHOEBE 2.2 installed. (You can comment out this line if you don't use pip for your installation or don't want to update to the latest release). # In[ ]: get_ipython().system('pip install -I "phoebe>=2.2,<2.3"') # As always, let's do imports and initialize a logger and a new bundle. See [Building a System](../tutorials/building_a_system.ipynb) for more details. # In[1]: get_ipython().run_line_magic('matplotlib', 'inline') # In[2]: import phoebe from phoebe import u # units import numpy as np import matplotlib.pyplot as plt logger = phoebe.logger() b = phoebe.default_binary() # Model without Spots # -------------------------- # In[3]: b.add_dataset('lc', times=phoebe.linspace(0,1,101)) # In[4]: b.run_compute(irrad_method='none', model='no_spot') # Adding Spots # --------------------- # Let's add a spot to the primary component in our binary. # # The 'colat' parameter defines the colatitude on the star measured from its North (spin) Pole. The 'long' parameter measures the longitude of the spot - with longitude = 0 being defined as pointing towards the other star at t0. See the [spots tutorial](../tutorials/spots.ipynb) for more details. # In[5]: b.add_feature('spot', component='primary', feature='spot01', relteff=0.9, radius=30, colat=45, long=90) # In[6]: b.run_compute(irrad_method='none', model='with_spot') # Comparing Light Curves # ------------------------------ # In[7]: afig, mplfig = b.plot(show=True, legend=True) # In[ ]:
phoebe-project/phoebe2-docs
2.2/examples/binary_spots.py
Python
gpl-3.0
1,686
0.008304
#! /usr/bin/env python # coding=utf-8 # Copyright (c) 2019 Uber Technologies, Inc. # # 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 h5py import numpy as np from ludwig.constants import PREPROCESSING from ludwig.data.batcher.random_access import RandomAccessBatcher from ludwig.data.dataset.base import Dataset from ludwig.data.sampler import DistributedSampler from ludwig.utils.data_utils import to_numpy_dataset class PandasDataset(Dataset): def __init__(self, dataset, features, data_hdf5_fp): self.features = features self.data_hdf5_fp = data_hdf5_fp self.size = len(dataset) self.dataset = to_numpy_dataset(dataset) def get(self, proc_column, idx=None): if idx is None: idx = range(self.size) if (self.data_hdf5_fp is None or PREPROCESSING not in self.features[proc_column] or 'in_memory' not in self.features[proc_column][ 'preprocessing']): return self.dataset[proc_column][idx] if self.features[proc_column][PREPROCESSING]['in_memory']: return self.dataset[proc_column][idx] sub_batch = self.dataset[proc_column][idx] indices = np.empty((3, len(sub_batch)), dtype=np.int64) indices[0, :] = sub_batch indices[1, :] = np.arange(len(sub_batch)) indices = indices[:, np.argsort(indices[0])] with h5py.File(self.data_hdf5_fp, 'r') as h5_file: im_data = h5_file[proc_column + '_data'][indices[0, :], :, :] indices[2, :] = np.arange(len(sub_batch)) indices = indices[:, np.argsort(indices[1])] return im_data[indices[2, :]] def get_dataset(self): return self.dataset def __len__(self): return self.size def initialize_batcher(self, batch_size=128, should_shuffle=True, seed=0, ignore_last=False, horovod=None): sampler = DistributedSampler(len(self), shuffle=should_shuffle, seed=seed, horovod=horovod) batcher = RandomAccessBatcher(self, sampler, batch_size=batch_size, ignore_last=ignore_last) return batcher
uber/ludwig
ludwig/data/dataset/pandas.py
Python
apache-2.0
3,028
0
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations class Migration(migrations.Migration): dependencies = [ ('comercial', '0046_auto_20151004_1747'), ] operations = [ migrations.AddField( model_name='itemgrupodocumento', name='titulo_centralizado', field=models.BooleanField(default=False), ), ]
dudanogueira/microerp
microerp/comercial/migrations/0047_itemgrupodocumento_titulo_centralizado.py
Python
lgpl-3.0
430
0
import file ciphertext = str(file.openAsAscii("cipher.txt"),"utf-8").replace(" ","") matches = 0 diffs = set() N=5 print(len(ciphertext)/N) for wordlen in range(N*5,N*8,N): print("Wordlen: {0}".format(wordlen)) for wordIndex in range(len(ciphertext)-wordlen): for word2Index in range(wordIndex+wordlen,len(ciphertext) - wordlen,N): word,word2 = ciphertext[wordIndex:wordIndex+wordlen:N],ciphertext[word2Index:word2Index+wordlen:N] if word == word2: print(word,word2,wordIndex,word2Index) matches += 1 diffs.add(word2Index - wordIndex) print(diffs)
tim-clifford/py-cipher
src/test1.py
Python
mit
569
0.038664
#!/usr/bin/env python2.7 import sys, getopt if len(sys.argv) < 3: print """ Usage: compare_blast.py <input1.b6> <input2.b6> """ blast1= sys.argv[1] blast2= sys.argv[2] dict1= {} for line in open(blast1): line= line.strip().split("\t") query= line[0].split()[0] dict1[query]= line dict2= {} for line in open(blast2): line= line.strip().split("\t") query= line[0].split()[0] dict2[query]= line blast1better= blast1.split(".b6")[0] + "_good.b6" blast1worse= blast1.split(".b6")[0] + "_bad.b6" blast2better= blast2.split(".b6")[0] + "_good.b6" blast2worse= blast2.split(".b6")[0] + "_bad.b6" b1b_handle= open(blast1better, 'w') b1w_handle= open(blast1worse, 'w') b2b_handle= open(blast2better, 'w') b2w_handle= open(blast2worse, 'w') for query in dict1: line1= dict1[query] if query not in dict2: b1b_handle.write("\t".join(line1)+"\n") else: line2= dict2[query] if float(line1[-1]) > float(line2[-1]): b1b_handle.write("\t".join(line1)+"\n") else: b1w_handle.write("\t".join(line1)+"\n") for query in dict2: line2= dict2[query] if query not in dict1: b2b_handle.write("\t".join(line2)+"\n") else: line1= dict1[query] if float(line2[-1]) > float(line1[-1]): b2b_handle.write("\t".join(line2)+"\n") else: b2w_handle.write("\t".join(line2)+"\n") b1b_handle.close() b1w_handle.close() b2b_handle.close() b2w_handle.close()
alexherns/biotite-scripts
compare_blasts.py
Python
mit
1,490
0.015436
# -*- coding: utf-8 -*- from __future__ import unicode_literals from datetime import date from decimal import Decimal, ROUND_DOWN from django.contrib.sites.models import Site from django.db import models from django.db.models import Sum from django.db.models.signals import post_save from django.dispatch import receiver from .utils import duration_string, duration_decimal from conf.utils import current_site_id from conf.managers import CurrentSiteManager @receiver(post_save) def add_current_site(sender, instance, **kwargs): """ Add the current site to a model's sites property after a save. This is required in post save because ManyToManyField fields require an existing key. TODO: Don't run this on *every* post_save. """ if hasattr(instance, 'sites'): if not instance.sites.all(): instance.sites = Site.objects.filter(id=current_site_id()) instance.save() class Client(models.Model): name = models.CharField(max_length=255) archive = models.BooleanField(default=False) payment_id = models.CharField(max_length=255, blank=True, null=True) invoice_email = models.EmailField(max_length=255, blank=True, null=True) sites = models.ManyToManyField(Site) objects = models.Manager() on_site = CurrentSiteManager() class Meta: default_permissions = ('view', 'add', 'change', 'delete') ordering = ['-id'] def __str__(self): return 'Client: ' + self.name def get_total_projects(self): return self.projects.count() def get_total_duration(self): return duration_string(self.projects.aggregate( Sum('entries__duration') )['entries__duration__sum']) class Project(models.Model): client = models.ForeignKey('Client', related_name='projects') name = models.CharField(max_length=255) archive = models.BooleanField(default=False) estimate = models.DecimalField(max_digits=10, decimal_places=2, blank=True, null=True) hourly_rate = models.DecimalField(max_digits=10, decimal_places=2, blank=True, null=True) class Meta: default_permissions = ('view', 'add', 'change', 'delete') ordering = ['client', '-id'] def __str__(self): return 'Project: ' + self.name def get_total_entries(self): return self.entries.count() def get_total_cost(self): total_cost = Decimal() for entry in self.entries.iterator(): try: if entry.task.hourly_rate: total_cost += ( duration_decimal(entry.duration) * entry.task.hourly_rate ) except: continue return total_cost.quantize(Decimal('.01'), rounding=ROUND_DOWN) def get_total_duration(self): return duration_string(self.entries.aggregate( Sum('duration') )['duration__sum']) def get_percent_done(self): if self.estimate is not None: total_cost = Decimal(self.get_total_cost()) total_estimate = Decimal(self.estimate) if total_cost != 0 and total_estimate != 0: return int(100 * (total_cost/total_estimate)) return None class Task(models.Model): name = models.CharField(max_length=255) hourly_rate = models.DecimalField(max_digits=10, decimal_places=2, blank=True, null=True) sites = models.ManyToManyField(Site) objects = models.Manager() on_site = CurrentSiteManager() class Meta: default_permissions = ('view', 'add', 'change', 'delete') ordering = ['-id'] def __str__(self): return 'Task: ' + self.name class EntryManager(models.Manager): def invoiced(self): return super(EntryManager, self).get_queryset().filter( invoices__isnull=False) def uninvoiced(self): return super(EntryManager, self).get_queryset().filter( invoices__isnull=True) class Entry(models.Model): project = models.ForeignKey('Project', related_name='entries') task = models.ForeignKey('core.Task', related_name='entries', blank=True, null=True) user = models.ForeignKey('auth.User', related_name='entries') date = models.DateField(blank=True) duration = models.DurationField(blank=True) note = models.TextField(blank=True, null=True) site = models.ForeignKey(Site, default=current_site_id(), on_delete=models.CASCADE) objects = EntryManager() on_site = CurrentSiteManager() class Meta: default_permissions = ('view', 'add', 'change', 'delete') ordering = ['-date', '-id'] verbose_name_plural = 'Entries' def save(self, *args, **kwargs): if not self.date: self.date = date.today() if not self.site: self.site = Site.objects.get(id=current_site_id()) super(Entry, self).save(*args, **kwargs) def __str__(self): return 'Entry for ' + self.project.name + ' by ' + self.user.username def is_invoiced(self): if self.invoices.count() > 0: return True return False class Invoice(models.Model): client = models.ForeignKey('Client') # Redundant with entries? note = models.CharField(max_length=255, blank=True, null=True) entries = models.ManyToManyField('Entry', related_name='invoices') created = models.DateTimeField(auto_now_add=True) paid = models.DateTimeField(blank=True, null=True) transaction_id = models.CharField(max_length=255, blank=True, null=True) site = models.ForeignKey(Site, default=current_site_id(), on_delete=models.CASCADE) objects = models.Manager() on_site = CurrentSiteManager() class Meta: default_permissions = ('view', 'add', 'change', 'delete') def save(self, *args, **kwargs): self.site = Site.objects.get(id=current_site_id()) super(Invoice, self).save(*args, **kwargs) def __str__(self): return 'Invoice: ' + self.client.name def total_duration(self): total = 0 for entry in self.entries: total += entry.duration def total_billed(self): total = 0 for entry in self.entries: if entry.task.hourly_rate: total += entry.duration * entry.hourly_rate return total
muhleder/timestrap
core/models.py
Python
bsd-2-clause
6,476
0.000463
"""Development settings and globals.""" from os.path import join, normpath from base import * ########## DEBUG CONFIGURATION # See: https://docs.djangoproject.com/en/dev/ref/settings/#debug DEBUG = True # See: https://docs.djangoproject.com/en/dev/ref/settings/#template-debug TEMPLATE_DEBUG = DEBUG ########## END DEBUG CONFIGURATION ########## EMAIL CONFIGURATION # See: https://docs.djangoproject.com/en/dev/ref/settings/#email-backend EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' ########## END EMAIL CONFIGURATION ########## DATABASE CONFIGURATION # See: https://docs.djangoproject.com/en/dev/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': '', 'USER': '', 'PASSWORD': '', 'HOST': '', 'PORT': '', } } ########## END DATABASE CONFIGURATION ########## CACHE CONFIGURATION # See: https://docs.djangoproject.com/en/dev/ref/settings/#caches CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', } } ########## END CACHE CONFIGURATION ########## TOOLBAR CONFIGURATION # See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation INSTALLED_APPS += ( 'debug_toolbar', ) # See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation INTERNAL_IPS = ('127.0.0.1',) # See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation MIDDLEWARE_CLASSES += ( 'debug_toolbar.middleware.DebugToolbarMiddleware', ) # See: https://github.com/django-debug-toolbar/django-debug-toolbar#installation DEBUG_TOOLBAR_CONFIG = { 'INTERCEPT_REDIRECTS': False, 'SHOW_TEMPLATE_CONTEXT': True, } ########## END TOOLBAR CONFIGURATION
assertnotnull/servicebusmtl
servicebusmtl/servicebusmtl/settings/local.py
Python
mit
1,780
0.007865
""" Module for processing Sitemaps. Note: The main purpose of this module is to provide support for the SitemapSpider, its API is subject to change without notice. """ from urllib.parse import urljoin import lxml.etree class Sitemap: """Class to parse Sitemap (type=urlset) and Sitemap Index (type=sitemapindex) files""" def __init__(self, xmltext): xmlp = lxml.etree.XMLParser(recover=True, remove_comments=True, resolve_entities=False) self._root = lxml.etree.fromstring(xmltext, parser=xmlp) rt = self._root.tag self.type = self._root.tag.split('}', 1)[1] if '}' in rt else rt def __iter__(self): for elem in self._root.getchildren(): d = {} for el in elem.getchildren(): tag = el.tag name = tag.split('}', 1)[1] if '}' in tag else tag if name == 'link': if 'href' in el.attrib: d.setdefault('alternate', []).append(el.get('href')) else: d[name] = el.text.strip() if el.text else '' if 'loc' in d: yield d def sitemap_urls_from_robots(robots_text, base_url=None): """Return an iterator over all sitemap urls contained in the given robots.txt file """ for line in robots_text.splitlines(): if line.lstrip().lower().startswith('sitemap:'): url = line.split(':', 1)[1].strip() yield urljoin(base_url, url)
starrify/scrapy
scrapy/utils/sitemap.py
Python
bsd-3-clause
1,501
0.000666
# -*- coding: utf-8 -*- from flask import current_app as app from sqlalchemy_utils import TSVectorType db = app.db class Author(db.Model): id = db.Column(db.Integer(), primary_key=True, nullable=False) name = db.Column(db.Unicode(1024), nullable=False, unique=True) name_vector = db.Column(TSVectorType('name'))
philiptzou/taxonwiki
taxonwiki/models/author.py
Python
mit
331
0
# -*- coding: utf-8 -*- from __future__ import print_function, unicode_literals import logging import os import sys try: from magic import from_file as magic_from_file except ImportError: magic_from_file = None from six.moves import SimpleHTTPServer as srvmod from six.moves import socketserver class ComplexHTTPRequestHandler(srvmod.SimpleHTTPRequestHandler): SUFFIXES = ['', '.html', '/index.html'] def do_GET(self): # Try to detect file by applying various suffixes for suffix in self.SUFFIXES: if not hasattr(self, 'original_path'): self.original_path = self.path self.path = self.original_path + suffix path = self.translate_path(self.path) if os.path.exists(path): srvmod.SimpleHTTPRequestHandler.do_GET(self) logging.info("Found `%s`." % self.path) break logging.info("Tried to find `%s`, but it doesn't exist.", self.path) else: # Fallback if there were no matches logging.warning("Unable to find `%s` or variations.", self.original_path) def guess_type(self, path): """Guess at the mime type for the specified file. """ mimetype = srvmod.SimpleHTTPRequestHandler.guess_type(self, path) # If the default guess is too generic, try the python-magic library if mimetype == 'application/octet-stream' and magic_from_file: mimetype = magic_from_file(path, mime=True) return mimetype if __name__ == '__main__': PORT = len(sys.argv) in (2, 3) and int(sys.argv[1]) or 8000 SERVER = len(sys.argv) == 3 and sys.argv[2] or "" socketserver.TCPServer.allow_reuse_address = True try: httpd = socketserver.TCPServer( (SERVER, PORT), ComplexHTTPRequestHandler) except OSError as e: logging.error("Could not listen on port %s, server %s.", PORT, SERVER) sys.exit(getattr(e, 'exitcode', 1)) logging.info("Serving at port %s, server %s.", PORT, SERVER) try: httpd.serve_forever() except KeyboardInterrupt as e: logging.info("Shutting down server.") httpd.socket.close()
jimperio/pelican
pelican/server.py
Python
agpl-3.0
2,272
0
# # Copyright (c) 2013-2014, Scott J Maddox # # This file is part of SimplePL. # # SimplePL is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # SimplePL is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public # License along with SimplePL. If not, see # <http://www.gnu.org/licenses/>. # ####################################################################### # std lib imports import logging log = logging.getLogger(__name__) import time import string # third party imports #import serial # local imports SLEEP_TIME = 0.01 #TODO: make sure the asked for nm is available on the given grating? class FW102C(object): ''' Device driver for ThorLabs FW102C Motorized Filter Wheel. ''' def __init__(self, port, timeout=5.): # self._inst = serial.Serial(port, # baudrate=115200, # bytesize=serial.EIGHTBITS, # parity=serial.PARITY_NONE, # stopbits=serial.STOPBITS_ONE, # timeout=timeout) self.current_filter = 1 time.sleep(SLEEP_TIME * 100) def __read(self): r = self._inst.readline() log.debug("__read: return %s", r) return r def _read(self): r = self.__read() r = string.join(r.split()[1:-1]) # strip command echo and "ok" return r def __write(self, s): log.debug("__write: _inst.write(%s)", s) self._inst.write(s+"\r") def _write(self, s): self.__write(s) while True: if self.__read()[-1:] == "\r\n>": break def _ask(self, s): self.__write(s) return self._read() #TODO: check how it terminates this, and compensate def get_id(self): return self._ask('*idn?') #TODO: check how it confirms pos=1, if at all, and compensate def set_filter(self, i): ''' Sets the filter wheel position to the given index ''' if not isinstance(i, int) or i < 1 or i > 6: raise ValueError('i must be an integer in the range [1, 6]') #self._write('pos=%d'%i) log.debug("set_filter: %d", i) self.current_filter = i time.sleep(3) def get_filter(self): #return int(self._ask('pos?')) log.debug("get_filter: %d", self.current_filter) return self.current_filter if __name__ == "__main__": # enable DEBUG output logging.basicConfig(level=logging.DEBUG) # Test fw = FW102C(port=3) print fw.get_id() print fw.get_filter() fw.set_filter(1) print fw.get_filter() fw.set_filter(2) print fw.get_filter()
scott-maddox/simplepl
src/simplepl/instruments/drivers/thorlabs_fw102c_sim.py
Python
agpl-3.0
3,169
0.005364
"""switch to server-side creation timestamps Revision ID: 1dfc65e583bf Revises: 1b0b4e6fdf96 Create Date: 2018-02-08 23:06:09.384416 """ # revision identifiers, used by Alembic. revision = '1dfc65e583bf' down_revision = '1b0b4e6fdf96' from alembic import op from sqlalchemy.sql import text # SELECT table_name FROM information_schema.columns WHERE table_schema='inbox' AND column_name='created_at' TABLES = ['account', 'accounttransaction', 'actionlog', 'block', 'calendar', 'category', 'contact', 'contactsearchindexcursor', 'dataprocessingcache', 'event', 'folder', 'gmailauthcredentials', 'imapfolderinfo', 'imapfoldersyncstatus', 'imapuid', 'label', 'labelitem', 'message', 'messagecategory', 'messagecontactassociation', 'metadata', 'namespace', 'part', 'phonenumber', 'secret', 'thread', 'transaction'] def upgrade(): conn = op.get_bind() for table in TABLES: conn.execute(text('ALTER TABLE `{}` MODIFY COLUMN `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP'.format(table))) def downgrade(): conn = op.get_bind() for table in TABLES: conn.execute(text('ALTER TABLE `{}` MODIFY COLUMN `created_at` DATETIME NOT NULL'.format(table)))
closeio/nylas
migrations/versions/239_server_default_created_at.py
Python
agpl-3.0
1,186
0.006745
############################################################################### # # # This program is free software: you can redistribute it and/or modify # # it under the terms of the GNU General Public License as published by # # the Free Software Foundation, either version 3 of the License, or # # (at your option) any later version. # # # # This program is distributed in the hope that it will be useful, # # but WITHOUT ANY WARRANTY; without even the implied warranty of # # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # # GNU General Public License for more details. # # # # You should have received a copy of the GNU General Public License # # along with this program. If not, see <http://www.gnu.org/licenses/>. # # # ############################################################################### import os def version(): """Read program version from file.""" import drawm version_file = open(os.path.join(__path__[0], 'VERSION')) return version_file.read().strip()
dparks1134/DrawM
drawm/__init__.py
Python
gpl-3.0
1,491
0.000671
import sys sys.path.insert(0,'../src/') # Begin From obstacle_avoidance import rospy import math from math import sin, cos from geometry_msgs.msg import Twist from sensor_msgs.msg import LaserScan from collections import namedtuple Obstacle = namedtuple('Obstacle', ['r', 'theta']) # End From obstacle_avoidance from obstacle_avoidance import ObstacleAvoidance import unittest class TestCurvatureCalculations(unittest.TestCase): def test_left(self): # Obstacle = namedtuple('Obstacle', ['r', 'theta']) oa = ObstacleAvoidance() v = 2 omega = .1 originalCurvature = omega/v pathWidth = 1 filteredListOfRThetaPairs = [] filteredListOfRThetaPairs.append(Obstacle(r=1.6328, theta=-0.4421)) filteredListOfRThetaPairs.append(Obstacle(r=1.4904, theta=-0.2019)) filteredListOfRThetaPairs.append(Obstacle(r=1.0792, theta=-0.3143)) filteredListOfRThetaPairs.append(Obstacle(r=1.4444, theta=-0.3247)) filteredListOfRThetaPairs.append(Obstacle(r=1.1740, theta=-0.2601)) filteredListOfRThetaPairs.append(Obstacle(r=1.2565, theta=-0.2686)) filteredListOfRThetaPairs.append(Obstacle(r=1.5160, theta=-0.5730)) filteredListOfRThetaPairs.append(Obstacle(r=1.7103, theta=-0.5350)) filteredListOfRThetaPairs.append(Obstacle(r=1.2089, theta=-0.0008)) filteredListOfRThetaPairs.append(Obstacle(r=1.7064, theta=-0.5072)) curvatureToPassObstaclesOnLeft = oa.calculateCurvatureToPassObstaclesOnLeft(originalCurvature, pathWidth, filteredListOfRThetaPairs) print(str(curvatureToPassObstaclesOnLeft)) self.assertTrue(abs(curvatureToPassObstaclesOnLeft-0.8240)<0.001) def test_right(self): # Obstacle = namedtuple('Obstacle', ['r', 'theta']) oa = ObstacleAvoidance() v = 2 omega = .1 originalCurvature = omega/v pathWidth = 1 filteredListOfRThetaPairs = [] filteredListOfRThetaPairs.append(Obstacle(r=1.6328, theta=-0.4421)) filteredListOfRThetaPairs.append(Obstacle(r=1.4904, theta=-0.2019)) filteredListOfRThetaPairs.append(Obstacle(r=1.0792, theta=-0.3143)) filteredListOfRThetaPairs.append(Obstacle(r=1.4444, theta=-0.3247)) filteredListOfRThetaPairs.append(Obstacle(r=1.1740, theta=-0.2601)) filteredListOfRThetaPairs.append(Obstacle(r=1.2565, theta=-0.2686)) filteredListOfRThetaPairs.append(Obstacle(r=1.5160, theta=-0.5730)) filteredListOfRThetaPairs.append(Obstacle(r=1.7103, theta=-0.5350)) filteredListOfRThetaPairs.append(Obstacle(r=1.2089, theta=-0.0008)) filteredListOfRThetaPairs.append(Obstacle(r=1.7064, theta=-0.5072)) curvatureToPassObstaclesOnRight = oa.calculateCurvatureToPassObstaclesOnRight(originalCurvature, pathWidth, filteredListOfRThetaPairs) print(str(curvatureToPassObstaclesOnRight)) self.assertTrue(abs(curvatureToPassObstaclesOnRight-(-1.8228))<0.001) if __name__ == '__main__': unittest.main()
cwrucutter/snowmower_obstacles
test/test_obstacle_avoidance.py
Python
mit
3,038
0.004937
from os import curdir, sep from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer from urlparse import urlparse, parse_qs from subprocess import call import SocketServer import osc import random import json import socket import sys class Drummers(object): def __init__(self): self.drummer_map = {} self.num_pads = 16 self.drum_width = 400 self.drum_height = 200 self.drum_layout = (8, 2) #8 wide, two high def add_touches(self, ip_address, coords): self.drummer_map[ip_address] = coords def get_total_hits(self): hits = [0] * self.num_pads for coords in self.drummer_map.values(): for c in coords: p = self.coord_to_pad(c) if (p >= 0 and p < (self.drum_layout[0] * self.drum_layout[1])): hits[self.coord_to_pad(c)] += 1 return hits def coord_to_pad(self, c): pix_per_pad_w = self.drum_width / self.drum_layout[0] pix_per_pad_h = self.drum_height / self.drum_layout[1] column = c[0] // pix_per_pad_w row = c[1] // pix_per_pad_h pad = row * self.drum_layout[0] + column return pad drummers = Drummers() def handle_input(input, ipAddress): for evt in input: if evt['elementId'] == "touchmove": if evt['action'] == "MultitouchTouchList": osc.sendMsg("/movestart", [ipAddress, evt['coords'][0][0], evt['coords'][0][1]] , "127.0.0.1", 9002) if evt['action'] == "MultitouchTouchListEnd": osc.sendMsg("/moveend", [ipAddress, evt['coords'][0][0], evt['coords'][0][1]] , "127.0.0.1", 9002) if evt['elementId'] == "touchshoot": if evt['action'] == "MultitouchTouchList": osc.sendMsg("/shootstart", [ipAddress, evt['coords'][0][0], evt['coords'][0][1]] , "127.0.0.1", 9002) if evt['action'] == "MultitouchTouchListEnd": osc.sendMsg("/shootend", [ipAddress, evt['coords'][0][0], evt['coords'][0][1]] , "127.0.0.1", 9002) if evt['elementId'] == "drumpad": if evt['action'] == "MultitouchTouchList": drummers.add_touches(ipAddress, evt['coords']) hits = drummers.get_total_hits() print "hits =", hits, len(hits) osc.sendMsg("/drumhitlist", [int(h) for h in hits], "127.0.0.1", 6767) osc.sendMsg("/drumhitlist", [int(h) for h in hits], "127.0.0.1", 6768) if evt['action'] == "MultitouchTouchNone": print "got none!" drummers.add_touches(ipAddress, []) hits = drummers.get_total_hits() print "hits =", hits, len(hits) osc.sendMsg("/drumhitlist", [int(h) for h in hits], "127.0.0.1", 6767) osc.sendMsg("/drumhitlist", [int(h) for h in hits], "127.0.0.1", 6768) if evt['elementId'] == "drumpadc": print "touish:", evt class ThreadedHTTPServer(SocketServer.ThreadingMixIn, HTTPServer): daemon_threads = True pass move_id = 0 PORT = 8080 if len(sys.argv) == 2: PORT = int(sys.argv[1]) class MyHandler(BaseHTTPRequestHandler): def do_POST(self): if (True): try: clen = int(self.headers.getheader('content-length')) incoming = self.rfile.read(clen) self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write("ok") incoming_parsed = json.loads(incoming) handle_input(incoming_parsed, self.address_string()) except IOError: self.send_error(404,'File Not Found: %s' % self.path) def do_GET(self): # print "got a request from", self.address_string() if (self.path in ["/demo-game.html", "/demo-drum.html", "/touchlib.js", "/"]): try: if (self.path == "/"): self.path = "/demo-game.html" f = open(curdir + sep + self.path) #self.path has /test.html self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write(f.read()) f.close() except IOError: self.send_error(404,'File Not Found: %s' % self.path) else: self.send_error(404,'File Not Found: %s' % self.path) def main(): try: # server = HTTPServer(('', PORT), MyHandler) server = ThreadedHTTPServer(('', PORT), MyHandler) print 'Welcome to the machine...(%s:%d)'%(socket.gethostbyname(socket.gethostname()), PORT) server.serve_forever() except KeyboardInterrupt: print '^C received, shutting down server' server.socket.close() if __name__ == '__main__': osc.init() main()
aturley/spaceshooter
server-demogame.py
Python
gpl-3.0
4,932
0.006894
#!/usr/bin/env python # -*- coding: utf-8 - # # This file is part of restkit released under the MIT license. # See the NOTICE for more information. from StringIO import StringIO import urlparse import urllib try: from webob import Request as BaseRequest except ImportError: raise ImportError('WebOb (http://pypi.python.org/pypi/WebOb) is required') from .wsgi_proxy import Proxy __doc__ = '''Subclasses of webob.Request who use restkit to get a webob.Response via restkit.ext.wsgi_proxy.Proxy. Example:: >>> req = Request.blank('http://pypi.python.org/pypi/restkit') >>> resp = req.get_response() >>> print resp #doctest: +ELLIPSIS 200 OK Date: ... Transfer-Encoding: chunked Content-Type: text/html; charset=utf-8 Server: Apache/2... <BLANKLINE> <?xml version="1.0" encoding="UTF-8"?> ... ''' PROXY = Proxy(allowed_methods=['GET', 'POST', 'HEAD', 'DELETE', 'PUT', 'PURGE']) class Method(property): def __init__(self, name): self.name = name def __get__(self, instance, klass): if not instance: return self instance.method = self.name.upper() def req(*args, **kwargs): return instance.get_response(*args, **kwargs) return req class Request(BaseRequest): get = Method('get') post = Method('post') put = Method('put') head = Method('head') delete = Method('delete') def get_response(self): if self.content_length < 0: self.content_length = 0 if self.method in ('DELETE', 'GET'): self.body = '' elif self.method == 'POST' and self.POST: body = urllib.urlencode(self.POST.copy()) stream = StringIO(body) stream.seek(0) self.body_file = stream self.content_length = stream.len if 'form' not in self.content_type: self.content_type = 'application/x-www-form-urlencoded' self.server_name = self.host return BaseRequest.get_response(self, PROXY) __call__ = get_response def set_url(self, url_or_path): path = url_or_path.lstrip('/') if '?' in path: path, self.query_string = path.split('?', 1) if path.startswith('http'): url = path else: self.path_info = '/'+path url = self.url self.scheme, self.host, self.path_info = urlparse.urlparse(url)[0:3]
arnaudsj/restkit
restkit/contrib/webob_api.py
Python
mit
2,457
0.003256
# -*- test-case-name: twisted.test.test_threadpool -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ twisted.python.threadpool: a pool of threads to which we dispatch tasks. In most cases you can just use C{reactor.callInThread} and friends instead of creating a thread pool directly. """ from __future__ import division, absolute_import try: from Queue import Queue except ImportError: from queue import Queue import contextlib import threading import copy from twisted.python import log, context, failure WorkerStop = object() class ThreadPool: """ This class (hopefully) generalizes the functionality of a pool of threads to which work can be dispatched. L{callInThread} and L{stop} should only be called from a single thread, unless you make a subclass where L{stop} and L{_startSomeWorkers} are synchronized. @ivar started: Whether or not the thread pool is currently running. @type started: L{bool} @ivar threads: List of workers currently running in this thread pool. @type threads: L{list} """ min = 5 max = 20 joined = False started = False workers = 0 name = None threadFactory = threading.Thread currentThread = staticmethod(threading.currentThread) def __init__(self, minthreads=5, maxthreads=20, name=None): """ Create a new threadpool. @param minthreads: minimum number of threads in the pool @param maxthreads: maximum number of threads in the pool """ assert minthreads >= 0, 'minimum is negative' assert minthreads <= maxthreads, 'minimum is greater than maximum' self.q = Queue(0) self.min = minthreads self.max = maxthreads self.name = name self.waiters = [] self.threads = [] self.working = [] def start(self): """ Start the threadpool. """ self.joined = False self.started = True # Start some threads. self.adjustPoolsize() def startAWorker(self): self.workers += 1 name = "PoolThread-%s-%s" % (self.name or id(self), self.workers) newThread = self.threadFactory(target=self._worker, name=name) self.threads.append(newThread) newThread.start() def stopAWorker(self): self.q.put(WorkerStop) self.workers -= 1 def __setstate__(self, state): self.__dict__ = state ThreadPool.__init__(self, self.min, self.max) def __getstate__(self): state = {} state['min'] = self.min state['max'] = self.max return state def _startSomeWorkers(self): neededSize = self.q.qsize() + len(self.working) # Create enough, but not too many while self.workers < min(self.max, neededSize): self.startAWorker() def callInThread(self, func, *args, **kw): """ Call a callable object in a separate thread. @param func: callable object to be called in separate thread @param *args: positional arguments to be passed to C{func} @param **kw: keyword args to be passed to C{func} """ self.callInThreadWithCallback(None, func, *args, **kw) def callInThreadWithCallback(self, onResult, func, *args, **kw): """ Call a callable object in a separate thread and call C{onResult} with the return value, or a L{twisted.python.failure.Failure} if the callable raises an exception. The callable is allowed to block, but the C{onResult} function must not block and should perform as little work as possible. A typical action for C{onResult} for a threadpool used with a Twisted reactor would be to schedule a L{twisted.internet.defer.Deferred} to fire in the main reactor thread using C{.callFromThread}. Note that C{onResult} is called inside the separate thread, not inside the reactor thread. @param onResult: a callable with the signature C{(success, result)}. If the callable returns normally, C{onResult} is called with C{(True, result)} where C{result} is the return value of the callable. If the callable throws an exception, C{onResult} is called with C{(False, failure)}. Optionally, C{onResult} may be C{None}, in which case it is not called at all. @param func: callable object to be called in separate thread @param *args: positional arguments to be passed to C{func} @param **kwargs: keyword arguments to be passed to C{func} """ if self.joined: return ctx = context.theContextTracker.currentContext().contexts[-1] o = (ctx, func, args, kw, onResult) self.q.put(o) if self.started: self._startSomeWorkers() @contextlib.contextmanager def _workerState(self, stateList, workerThread): """ Manages adding and removing this worker from a list of workers in a particular state. @param stateList: the list managing workers in this state @param workerThread: the thread the worker is running in, used to represent the worker in stateList """ stateList.append(workerThread) try: yield finally: stateList.remove(workerThread) def _worker(self): """ Method used as target of the created threads: retrieve a task to run from the threadpool, run it, and proceed to the next task until threadpool is stopped. """ ct = self.currentThread() o = self.q.get() while o is not WorkerStop: with self._workerState(self.working, ct): ctx, function, args, kwargs, onResult = o del o try: result = context.call(ctx, function, *args, **kwargs) success = True except: success = False if onResult is None: context.call(ctx, log.err) result = None else: result = failure.Failure() del function, args, kwargs if onResult is not None: try: context.call(ctx, onResult, success, result) except: context.call(ctx, log.err) del ctx, onResult, result with self._workerState(self.waiters, ct): o = self.q.get() self.threads.remove(ct) def stop(self): """ Shutdown the threads in the threadpool. """ self.joined = True self.started = False threads = copy.copy(self.threads) while self.workers: self.q.put(WorkerStop) self.workers -= 1 # and let's just make sure # FIXME: threads that have died before calling stop() are not joined. for thread in threads: thread.join() def adjustPoolsize(self, minthreads=None, maxthreads=None): if minthreads is None: minthreads = self.min if maxthreads is None: maxthreads = self.max assert minthreads >= 0, 'minimum is negative' assert minthreads <= maxthreads, 'minimum is greater than maximum' self.min = minthreads self.max = maxthreads if not self.started: return # Kill of some threads if we have too many. while self.workers > self.max: self.stopAWorker() # Start some threads if we have too few. while self.workers < self.min: self.startAWorker() # Start some threads if there is a need. self._startSomeWorkers() def dumpStats(self): log.msg('queue: %s' % self.q.queue) log.msg('waiters: %s' % self.waiters) log.msg('workers: %s' % self.working) log.msg('total: %s' % self.threads)
hlzz/dotfiles
graphics/VTK-7.0.0/ThirdParty/Twisted/twisted/python/threadpool.py
Python
bsd-3-clause
8,392
0.002026
""" ===================== SVM: Weighted samples ===================== Plot decision function of a weighted dataset, where the size of points is proportional to its weight. """ print __doc__ import numpy as np import pylab as pl from sklearn import svm # we create 20 points np.random.seed(0) X = np.r_[np.random.randn(10, 2) + [1, 1], np.random.randn(10, 2)] Y = [1] * 10 + [-1] * 10 sample_weight = 100 * np.abs(np.random.randn(20)) # and assign a bigger weight to the last 10 samples sample_weight[:10] *= 10 # # fit the model clf = svm.SVC() clf.fit(X, Y, sample_weight=sample_weight) # plot the decision function xx, yy = np.meshgrid(np.linspace(-4, 5, 500), np.linspace(-4, 5, 500)) Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) # plot the line, the points, and the nearest vectors to the plane pl.contourf(xx, yy, Z, alpha=0.75, cmap=pl.cm.bone) pl.scatter(X[:, 0], X[:, 1], c=Y, s=sample_weight, alpha=0.9, cmap=pl.cm.bone) pl.axis('off') pl.show()
seckcoder/lang-learn
python/sklearn/examples/svm/plot_weighted_samples.py
Python
unlicense
999
0.003003
#! /usr/bin/env python3 from __future__ import print_function import argparse import os import sys def parse_args(): parser = argparse.ArgumentParser() parser.add_argument('locale_dir') return parser.parse_args() args = parse_args() basedir = os.path.abspath(os.path.join(os.path.abspath(__file__), '..', '..')) sys.path.insert(0, basedir) import setup po_dir = os.path.join(basedir, 'po') locale_dir = os.path.abspath(args.locale_dir) print('Building translations') print(po_dir, '-->', locale_dir) setup.build_translation_files(po_dir, locale_dir)
jendrikseipp/rednotebook-elementary
win/build-translations.py
Python
gpl-2.0
569
0.005272
# -*- coding: utf-8 -*- # This file is part of beets. # Copyright 2016, Adrian Sampson. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. """A simple utility for constructing filesystem-like trees from beets libraries. """ from __future__ import division, absolute_import, print_function from collections import namedtuple from beets import util Node = namedtuple('Node', ['files', 'dirs']) def _insert(node, path, itemid): """Insert an item into a virtual filesystem node.""" if len(path) == 1: # Last component. Insert file. node.files[path[0]] = itemid else: # In a directory. dirname = path[0] rest = path[1:] if dirname not in node.dirs: node.dirs[dirname] = Node({}, {}) _insert(node.dirs[dirname], rest, itemid) def libtree(lib): """Generates a filesystem-like directory tree for the files contained in `lib`. Filesystem nodes are (files, dirs) named tuples in which both components are dictionaries. The first maps filenames to Item ids. The second maps directory names to child node tuples. """ root = Node({}, {}) for item in lib.items(): dest = item.destination(fragment=True) parts = util.components(dest) _insert(root, parts, item.id) return root
clinton-hall/nzbToMedia
libs/common/beets/vfs.py
Python
gpl-3.0
1,839
0
import uuid from django.db import models from django.conf import settings from django.contrib.auth.models import AbstractUser from django.contrib.auth.models import BaseUserManager from django.utils import timezone from accelerator_abstract.models import BaseUserRole from accelerator_abstract.models.base_base_profile import EXPERT_USER_TYPE MAX_USERNAME_LENGTH = 30 class UserManager(BaseUserManager): use_in_migrations = True def _create_user(self, email, password, is_staff, is_superuser, **extra_fields): """ Creates and saves an User with the given email and password. """ now = timezone.now() if not email: raise ValueError('An email address must be provided.') email = self.normalize_email(email) if "is_active" not in extra_fields: extra_fields["is_active"] = True if "username" not in extra_fields: # For now we need to have a unique id that is at # most 30 characters long. Using uuid and truncating. # Ideally username goes away entirely at some point # since we're really using email. If we have to keep # username for some reason then we could switch over # to a string version of the pk which is guaranteed # be unique. extra_fields["username"] = str(uuid.uuid4())[:MAX_USERNAME_LENGTH] user = self.model(email=email, is_staff=is_staff, is_superuser=is_superuser, last_login=None, date_joined=now, **extra_fields) user.set_password(password) user.save(using=self._db) return user def create_user(self, email=None, password=None, **extra_fields): return self._create_user(email, password, False, False, **extra_fields) def create_superuser(self, email, password, **extra_fields): return self._create_user(email, password, True, True, **extra_fields) class User(AbstractUser): # Override the parent email field to add uniqueness constraint email = models.EmailField(blank=True, unique=True) objects = UserManager() class Meta: db_table = 'auth_user' managed = settings.ACCELERATOR_MODELS_ARE_MANAGED def __init__(self, *args, **kwargs): super(User, self).__init__(*args, **kwargs) self.startup = None self.team_member = None self.profile = None self.user_finalist_roles = None class AuthenticationException(Exception): pass def __str__(self): return self.email def full_name(self): fn = self.first_name ln = self.last_name if fn and ln: name = u"%s %s" % (fn, ln) else: name = str(self.email) return name def user_phone(self): return self._get_profile().phone def image_url(self): return self._get_profile().image_url() def team_member_id(self): return self.team_member.id if self._get_member() else '' def user_title(self): return self._get_title_and_company()['title'] def user_twitter_handle(self): return self._get_profile().twitter_handle def user_linked_in_url(self): return self._get_profile().linked_in_url def user_facebook_url(self): return self._get_profile().facebook_url def user_personal_website_url(self): return self._get_profile().personal_website_url def type(self): return self._get_profile().user_type def startup_name(self): return self._get_title_and_company()['company'] def _get_title_and_company(self): if self._is_expert() and self._has_expert_details(): profile = self._get_profile() title = profile.title company = profile.company return { "title": title, "company": company } self._get_member() title = self.team_member.title if self.team_member else "" company = self.startup.name if self._get_startup() else None return { "title": title, "company": company } def _has_expert_details(self): if self._is_expert(): profile = self._get_profile() return True if profile.title or profile.company else False def startup_industry(self): return self.startup.primary_industry if self._get_startup() else None def top_level_startup_industry(self): industry = ( self.startup.primary_industry if self._get_startup() else None) return industry.parent if industry and industry.parent else industry def startup_status_names(self): if self._get_startup(): return [startup_status.program_startup_status.startup_status for startup_status in self.startup.startupstatus_set.all()] def finalist_user_roles(self): if not self.user_finalist_roles: finalist_roles = BaseUserRole.FINALIST_USER_ROLES self.user_finalist_roles = self.programrolegrant_set.filter( program_role__user_role__name__in=finalist_roles ).values_list('program_role__name', flat=True).distinct() return list(self.user_finalist_roles) def program(self): return self.startup.current_program() if self._get_startup() else None def location(self): program = self.program() return program.program_family.name if program else None def year(self): program = self.program() return program.start_date.year if program else None def is_team_member(self): return True if self._get_member() else False def _get_startup(self): if not self.startup: self._get_member() if self.team_member: self.startup = self.team_member.startup return self.startup def _get_member(self): if not self.team_member: self.team_member = self.startupteammember_set.last() return self.team_member def _get_profile(self): if self.profile: return self.profile self.profile = self.get_profile() return self.profile def has_a_finalist_role(self): return len(self.finalist_user_roles()) > 0 def _is_expert(self): profile = self._get_profile() return profile.user_type == EXPERT_USER_TYPE.lower()
masschallenge/django-accelerator
simpleuser/models.py
Python
mit
6,632
0
#!/usr/bin/env python from distutils.core import setup setup( name='sewpy', version='1.0dev', packages=['sewpy'], description='Source Extractor Wrapper for Python', long_description=open('README.rst').read(), author='The MegaLUT developers', license='GPLv3', url='http://github.com/megalut/sewpy' )
megalut/sewpy
setup.py
Python
gpl-3.0
310
0.029032
# -*- coding: utf-8 -*- ############################################################################### # # Search # Returns current committees, subcommittees, and their membership. # # Python versions 2.6, 2.7, 3.x # # Copyright 2014, Temboo Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, # either express or implied. See the License for the specific # language governing permissions and limitations under the License. # # ############################################################################### from temboo.core.choreography import Choreography from temboo.core.choreography import InputSet from temboo.core.choreography import ResultSet from temboo.core.choreography import ChoreographyExecution import json class Search(Choreography): def __init__(self, temboo_session): """ Create a new instance of the Search Choreo. A TembooSession object, containing a valid set of Temboo credentials, must be supplied. """ super(Search, self).__init__(temboo_session, '/Library/SunlightLabs/Congress/Legislator/Search') def new_input_set(self): return SearchInputSet() def _make_result_set(self, result, path): return SearchResultSet(result, path) def _make_execution(self, session, exec_id, path): return SearchChoreographyExecution(session, exec_id, path) class SearchInputSet(InputSet): """ An InputSet with methods appropriate for specifying the inputs to the Search Choreo. The InputSet object is used to specify input parameters when executing this Choreo. """ def set_APIKey(self, value): """ Set the value of the APIKey input for this Choreo. ((required, string) The API Key provided by Sunlight Labs.) """ super(SearchInputSet, self)._set_input('APIKey', value) def set_AllLegislators(self, value): """ Set the value of the AllLegislators input for this Choreo. ((optional, boolean) A boolean flag indicating to search for all legislators even when they are no longer in office.) """ super(SearchInputSet, self)._set_input('AllLegislators', value) def set_Fields(self, value): """ Set the value of the Fields input for this Choreo. ((optional, string) A comma-separated list of fields to include in the response.) """ super(SearchInputSet, self)._set_input('Fields', value) def set_Filters(self, value): """ Set the value of the Filters input for this Choreo. ((optional, string) A JSON object containing key/value pairs to be used as filters.) """ super(SearchInputSet, self)._set_input('Filters', value) def set_Name(self, value): """ Set the value of the Name input for this Choreo. ((optional, string) Deprecated (retained for backward compatibility only).) """ super(SearchInputSet, self)._set_input('Name', value) def set_Order(self, value): """ Set the value of the Order input for this Choreo. ((optional, string) Used to order the results by field name (e.g. field__asc).) """ super(SearchInputSet, self)._set_input('Order', value) def set_Page(self, value): """ Set the value of the Page input for this Choreo. ((optional, integer) The page offset.) """ super(SearchInputSet, self)._set_input('Page', value) def set_PerPage(self, value): """ Set the value of the PerPage input for this Choreo. ((optional, integer) The number of results to return per page.) """ super(SearchInputSet, self)._set_input('PerPage', value) def set_Query(self, value): """ Set the value of the Query input for this Choreo. ((conditional, string) A search term.) """ super(SearchInputSet, self)._set_input('Query', value) def set_ResponseFormat(self, value): """ Set the value of the ResponseFormat input for this Choreo. ((optional, string) The format that the response should be in. Valid values are: json (the default) and xml.) """ super(SearchInputSet, self)._set_input('ResponseFormat', value) class SearchResultSet(ResultSet): """ A ResultSet with methods tailored to the values returned by the Search Choreo. The ResultSet object is used to retrieve the results of a Choreo execution. """ def getJSONFromString(self, str): return json.loads(str) def get_Response(self): """ Retrieve the value for the "Response" output from this Choreo execution. (The response from the Sunlight Congress API.) """ return self._output.get('Response', None) class SearchChoreographyExecution(ChoreographyExecution): def _make_result_set(self, response, path): return SearchResultSet(response, path)
jordanemedlock/psychtruths
temboo/core/Library/SunlightLabs/Congress/Legislator/Search.py
Python
apache-2.0
5,201
0.005768
#### NOTICE: THIS FILE IS AUTOGENERATED #### MODIFICATIONS MAY BE LOST IF DONE IMPROPERLY #### PLEASE SEE THE ONLINE DOCUMENTATION FOR EXAMPLES from swgpy.object import * def create(kernel): result = Tangible() result.template = "object/tangible/painting/shared_painting_leia_wanted.iff" result.attribute_template_id = -1 result.stfName("frn_n","leia_wanted") #### BEGIN MODIFICATIONS #### #### END MODIFICATIONS #### return result
obi-two/Rebelion
data/scripts/templates/object/tangible/painting/shared_painting_leia_wanted.py
Python
mit
450
0.046667
# -*- coding: utf-8 -*- from __future__ import print_function import logging if __name__ == '__main__': logging.basicConfig() _log = logging.getLogger(__name__) from pyxb.exceptions_ import * import unittest import pyxb.binding.datatypes as xsd class Test_QName (unittest.TestCase): def testValid (self): valid = [ 'schema', 'xs:something', 'with.dots' ] for f in valid: self.assertEqual(f, xsd.QName(f)) def testInvalid (self): invalid = [ '-NonName', '-also:-not', 'and:-not', 'too:many:colons', ' whitespace ' ] for f in invalid: try: xsd.QName(f) print('Unexpected pass with %s' % (f,)) except: pass self.assertRaises(SimpleTypeValueError, xsd.QName, f) if __name__ == '__main__': unittest.main()
jonfoster/pyxb-upstream-mirror
tests/datatypes/test-QName.py
Python
apache-2.0
848
0.01533
# coding=utf-8 from WindowHelper import WindowHelper from constants import * class ListDialog: def __init__(self): self.win = WindowHelper.Instance() self.win.new_color((5, 51, 90), 'dark_blue') self.win.new_color((176, 194, 238), 'light_blue') self.win.new_font('Arial', 40, 'title') self.win.new_font('Arial', 20, 'sub_title') self.win.new_font('Arial', 25, 'options') def get_answer(self, choices, question=None, sub_text=None): page_label = self.win.go_to(self.win.new_page(question, WIN_WIDTH, WIN_HEIGHT, bg='white')) self.win.import_template('menu') if question is not None: self.win.edit_text('title_list_dialog', question) else: self.win.edit_text('title_list_dialog', " ") # TODO: Permettre de supprimer des éléments des templates if sub_text is not None: self.win.edit_text('sub_title_list_dialog', sub_text) else: self.win.edit_text('sub_title_list_dialog', " ") self.win.new_menu(choices, label='menu_list_dialog') opt = { "font": "options", "color": "dark_blue", "border": None, "color_active": "dark_blue", "border_active": "light_blue", "font_active": "options", "margin": WIN_MARGIN } self.win.add_menu('menu_list_dialog', 'centered', 180, opt=opt, page=page_label) self.win.refresh() return self.win.get_menu_result('menu_list_dialog')
totorigolo/WiiQuizz
ListDialog.py
Python
gpl-2.0
1,552
0.001935
class Register: @property def value(self): raise NotImplementedError @value.setter def value(self, value): raise NotImplementedError
Hexadorsimal/pynes
nes/processors/registers/register.py
Python
mit
166
0
# Przykladowy agent do zadania 'zagubiony Wumpus'. Agent porusza sie wezykiem. import random from action import Action # nie zmieniac nazwy klasy class Agent: # nie zmieniac naglowka konstruktora, tutaj agent dostaje wszystkie informacje o srodowisku def __init__(self, p, pj, pn, height, width, areaMap): self.times_moved = 0 self.direction = Action.LEFT # w ten sposob mozna zapamietac zmienne obiektu self.p = p self.pj = pj self.pn = pn self.height = height self.width = width self.map = areaMap # w tym przykladzie histogram wypelniany jest tak aby na planszy wyszedl gradient self.hist = [] for y in range(self.height): self.hist.append([]) for x in range(self.width): self.hist[y].append(float(y + x) / (self.width + self.height - 2)) # dopisac reszte inicjalizacji agenta return # nie zmieniac naglowka metody, tutaj agent dokonuje obserwacji swiata # sensor przyjmuje wartosc True gdy agent ma uczucie stania w jamie def sense(self, sensor): pass # nie zmieniac naglowka metody, tutaj agent decyduje w ktora strone sie ruszyc, # funkcja MUSI zwrocic jedna z wartosci [Action.UP, Action.DOWN, Action.LEFT, Action.RIGHT] def move(self): if self.times_moved < self.width - 1: self.times_moved += 1 return self.direction else: self.times_moved = 0 self.direction = Action.RIGHT if self.direction == Action.LEFT else Action.LEFT return Action.DOWN # nie zmieniac naglowka metody, tutaj agent udostepnia swoj histogram (ten z filtru # histogramowego), musi to byc tablica (lista list, krotka krotek...) o wymarach takich jak # plansza, pobranie wartosci agent.histogram()[y][x] zwraca prawdopodobienstwo stania na polu # w wierszu y i kolumnie x def histogram(self): return self.hist
uHappyLogic/lost-wumpus
agents/snake_agent.py
Python
mit
1,993
0.005018
from datetime import datetime from sqlalchemy import ( Column, ForeignKey, Integer, Text, Unicode, ) from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import ( scoped_session, sessionmaker, relationship ) from zope.sqlalchemy import ZopeTransactionExtension DBSession = scoped_session(sessionmaker(extension=ZopeTransactionExtension())) Base = declarative_base() class User(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(Unicode(255), nullable=False) password = Column(Unicode(255), nullable=False) email = Column(Unicode(255)) group_id = Column(Integer, ForeignKey('groups.id'), nullable=False) group = relationship('Group', backref='users') class Group(Base): __tablename__ = 'groups' id = Column(Integer, primary_key=True) name = Column(Unicode(255), nullable=False) class Permission(Base): __tablename__ = 'permissions' id = Column(Integer, primary_key=True) name = Column(Unicode(255), nullable=False) class Item(Base): __tablename__ = 'items' id = Column(Integer, primary_key=True) name = Column(Unicode(255), nullable=False) description = Column(Text) price = Column(Float, nullable=False, default=0.0) category_id = Column(Integer, ForeignKey('categories.id'), nullable=False) category = relationship('Category', backref='items') class Category(Base): __tablename__ = 'categories' id = Column(Integer, primary_key=True) name = Column(Unicode(255), nullable=False) parent_id = Column(Integer, ForeignKey('categories.id'), nullable=True) parent = relationship('Category', backref='children') class ItemImage(Base): __tablename__ = 'images' id = Column(Integer, primary_key=True) path = Column(Unicode(255), nullable=False) item_id = Column(Integer, ForeignKey('items.id'), nullable=False) item = relationship('Item', backref='images') class Comment(Base): __tablename__ = 'comments' id = Column(Integer, primary_key=True) user_id = Column(Integer, ForeignKey('users.id'), nullable=False) user = relationship('User', backref='comments') item_id = Column(Item, ForeignKey('items.id'), nullable=False) item = relationship('Item', backref='comments') rank = Column(Integer, nullable=False, default=3); content = Column(Text) class Cart(Base): __tablename__ = 'carts' id = Column(Integer, primary_key=True) # TODO: Many-to-many items = relationship('Item') user_id = Column(Integer, ForeignKey('users.id'), nullable=False) user = relationship('User', backref='cart') class Order(Base): __tablename__ = 'orders' id = Column(Integer, primary_key) user_id = Column(Integer, ForeignKey('users.id'), nullable=False) user = relationship('User', 'orders') # TODO: Many-to-many items = relationship('Item') add_time = Column(DateTime, nullable=False, default=datetime.now()) address = Column(Unicode(255), nullable=False) telephone = Column(Unicode(25), nullable=False)
DataMonster/Python
web/MyShop/myshop/models.py
Python
unlicense
2,927
0.022549
"""blah.""" from pyiem.util import get_dbconn pgconn = get_dbconn("idep") cursor = pgconn.cursor() cursor.execute( """ SELECT r.hs_id, r.huc_12, p.fpath, extract(year from valid) as yr, sum(runoff) as sum_runoff, sum(loss) as sum_loss, sum(delivery) as sum_delivery from results r JOIN flowpaths p on (r.hs_id = p.fid) WHERE r.scenario = 5 GROUP by r.hs_id, r.huc_12, fpath, yr """ ) print("CATCHMENT,HUC12,FPATH,YEAR,RUNOFF,LOSS,DELIVERY") for row in cursor: fpath = row[0] if fpath < 100: catchment = 0 else: catchment = int(str(fpath)[:-2]) print(str(catchment) + ",%s,%s,%s,%.4f,%.4f,%.4f" % row[1:])
akrherz/idep
scripts/convergence/dump_results.py
Python
mit
656
0
# -*- mode:python -*- # Copyright (c) 2007 MIPS Technologies, Inc. # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer; # redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution; # neither the name of the copyright holders nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # Authors: Jaidev Patwardhan from m5.defines import buildEnv from m5.params import * from m5.proxy import * from System import System class Lily2System(System): type = 'Lily2System' cxx_header = 'arch/lily2/system.hh' console = Param.String("file that contains the console code") bare_iron = Param.Bool(False, "Using Bare Iron Mode?") hex_file_name = Param.String("test.hex","hex file that contains [address,data] pairs") system_type = Param.UInt64("Type of system we are emulating") system_rev = Param.UInt64("Revision of system we are emulating") load_addr_mask = 0xffffffffff class LinuxLily2System(Lily2System): type = 'LinuxLily2System' cxx_header = 'arch/lily2/linux/system.hh' system_type = 34 system_rev = 1 << 10 boot_cpu_frequency = Param.Frequency(Self.cpu[0].clk_domain.clock.frequency, "boot processor frequency") class BareIronLily2System(Lily2System): type = 'BareIronLily2System' cxx_header = 'arch/lily2/bare_iron/system.hh' bare_iron = True system_type = 34 system_rev = 1 << 10 hex_file_name = Param.String('test.hex',"hex file that contains [address,data] pairs")
lixt/lily2-gem5
src/arch/lily2/Lily2System.py
Python
bsd-3-clause
2,762
0.003259
import os, sys from setuptools import setup, find_packages version = '0.4' install_requires = ['setuptools', 'PyYAML'] if sys.version_info < (2, 7): install_requires.append('simplejson') install_requires.append('argparse') def read(fname): return open(os.path.join(os.path.dirname(__file__), fname)).read() setup( name='varstack', version=version, description='A tool to create stacked configuration structures', url = 'https://github.com/conversis/varstack', license = 'MIT', author='Dennis Jacobfeuerborn', author_email='d.jacobfeuerborn@conversis.de', packages=['varstack'], scripts=['bin/varstack'], install_requires=install_requires, )
conversis/varstack
setup.py
Python
mit
697
0.010043
# Copyright 2014-2021 The PySCF Developers. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ''' Extension to scipy.linalg module developed for PBC branch. ''' import numpy as np import scipy.linalg def davidson_nosymm(matvec,size,nroots,Adiag=None): '''Davidson diagonalization method to solve A c = E c when A is not Hermitian. ''' # We don't pass args def matvec_args(vec, args): return matvec(vec) nroots = min(nroots,size) #if Adiag == None: # Adiag = matvec(numpy.ones(size)) # Currently not used: x = np.ones((size,1)) P = np.ones((size,1)) arnold = Arnoldi(matvec_args, x, P, nroots=nroots) return arnold.solve() VERBOSE = False class Arnoldi: def __init__(self,matr_multiply,xStart,inPreCon,nroots=1,tol=1e-6): self.matrMultiply = matr_multiply self.size = xStart.shape[0] self.nEigen = min(nroots, self.size) self.maxM = min(30, self.size) self.maxOuterLoop = 10 self.tol = tol # # Creating initial guess and preconditioner # self.x0 = xStart.real.copy() self.iteration = 0 self.totalIter = 0 self.converged = False self.preCon = inPreCon.copy() # # Allocating other vectors # self.allocateVecs() def solve(self): while self.converged == 0: if self.totalIter == 0: self.guessInitial() for i in range(self.maxM): if self.deflated == 1: self.currentSize = self.nEigen if self.deflated == 0 and self.totalIter > 0: self.hMult() self.push_Av() self.constructSubspace() self.solveSubspace() self.constructSol() self.computeResidual() self.checkConvergence() self.deflated = 0 if self.converged: break self.updateVecs() self.checkDeflate() self.constructDeflatedSub() self.totalIter += 1 self.currentSize += 1 print("") print("Converged in %3d cycles" % self.totalIter) self.constructAllSolV() return self.outeigs, self.outevecs def allocateVecs(self): self.subH = np.zeros( shape=(self.maxM,self.maxM), dtype=complex ) self.sol = np.zeros( shape=(self.maxM), dtype=complex ) self.dgks = np.zeros( shape=(self.maxM), dtype=complex ) self.nConv = np.zeros( shape=(self.maxM), dtype=int ) self.eigs = np.zeros( shape=(self.maxM), dtype=complex ) self.evecs = np.zeros( shape=(self.maxM,self.maxM), dtype=complex ) self.oldeigs = np.zeros( shape=(self.maxM), dtype=complex ) self.deigs = np.zeros( shape=(self.maxM), dtype=complex ) self.outeigs = np.zeros( shape=(self.nEigen), dtype=complex ) self.outevecs = np.zeros( shape=(self.size,self.nEigen), dtype=complex) self.currentSize = 0 self.Ax = np.zeros( shape=(self.size), dtype=complex ) self.res = np.zeros( shape=(self.size), dtype=complex ) self.vlist = np.zeros( shape=(self.maxM,self.size), dtype=complex ) self.cv = np.zeros( shape = (self.size), dtype = complex ) self.cAv = np.zeros( shape = (self.size), dtype = complex ) self.Avlist = np.zeros( shape=(self.maxM,self.size), dtype=complex ) self.dres = 999.9 self.resnorm = 999.9 self.cvEig = 0.1 self.ciEig = 0 self.deflated = 0 def guessInitial(self): nrm = np.linalg.norm(self.x0) self.x0 *= 1./nrm self.currentSize = self.nEigen for i in range(self.currentSize): self.vlist[i] *= 0.0 self.vlist[i,i] = 1.0 + 0.0*1j self.vlist[i] /= np.linalg.norm(self.vlist[i]) for i in range(self.currentSize): self.cv = self.vlist[i].copy() self.hMult() self.Avlist[i] = self.cAv.copy() self.constructSubspace() def hMult(self): args = 0 self.cAv = self.matrMultiply(self.cv.reshape(self.size),args) def push_Av(self): self.Avlist[self.currentSize-1] = self.cAv.reshape(self.size) def constructSubspace(self): if self.totalIter == 0 or self.deflated == 1: # construct the full block of v^*Av for i in range(self.currentSize): for j in range(self.currentSize): val = np.vdot(self.vlist[i],self.Avlist[j]) self.subH[i,j] = val else: for j in range(self.currentSize): if j <= (self.currentSize-1): val = np.vdot(self.vlist[j],self.Avlist[self.currentSize-1]) self.subH[j,self.currentSize-1] = val if j < (self.currentSize-1): val = np.vdot(self.vlist[self.currentSize-1],self.Avlist[j]) self.subH[self.currentSize-1,j] = val def solveSubspace(self): w, v = scipy.linalg.eig(self.subH[:self.currentSize,:self.currentSize]) idx = w.real.argsort() #imag_norm = np.linalg.norm(w.imag) #if imag_norm > 1e-12: # print " *************************************************** " # print " WARNING IMAGINARY EIGENVALUE OF NORM %.15g " % (imag_norm) # print " *************************************************** " #print "Imaginary norm eigenvectors = ", np.linalg.norm(v.imag) #print "Imaginary norm eigenvalue = ", np.linalg.norm(w.imag) v = v[:,idx] w = w[idx].real self.sol[:self.currentSize] = v[:,self.ciEig] self.evecs[:self.currentSize,:self.currentSize] = v self.eigs[:self.currentSize] = w[:self.currentSize] self.outeigs[:self.nEigen] = w[:self.nEigen] self.cvEig = self.eigs[self.ciEig] def constructAllSolV(self): for i in range(self.nEigen): self.sol[:] = self.evecs[:,i] self.cv = np.dot(self.vlist[:self.currentSize].transpose(),self.sol[:self.currentSize]) self.outevecs[:,i] = self.cv def constructSol(self): self.constructSolV() self.constructSolAv() def constructSolV(self): self.cv = np.dot(self.vlist[:self.currentSize].transpose(),self.sol[:self.currentSize]) def constructSolAv(self): self.cAv = np.dot(self.Avlist[:self.currentSize].transpose(),self.sol[:self.currentSize]) def computeResidual(self): self.res = self.cAv - self.cvEig * self.cv self.dres = np.vdot(self.res,self.res)**0.5 # # gram-schmidt for residual vector # for i in range(self.currentSize): self.dgks[i] = np.vdot( self.vlist[i], self.res ) self.res -= self.dgks[i]*self.vlist[i] # # second gram-schmidt to make them really orthogonal # for i in range(self.currentSize): self.dgks[i] = np.vdot( self.vlist[i], self.res ) self.res -= self.dgks[i]*self.vlist[i] self.resnorm = np.linalg.norm(self.res) self.res /= self.resnorm orthog = 0.0 for i in range(self.currentSize): orthog += np.vdot(self.res,self.vlist[i])**2.0 orthog = orthog ** 0.5 if not self.deflated: if VERBOSE: print("%3d %20.14f %20.14f %10.4g" % (self.ciEig, self.cvEig.real, self.resnorm.real, orthog.real)) #else: # print "%3d %20.14f %20.14f %20.14f (deflated)" % (self.ciEig, self.cvEig, # self.resnorm, orthog) self.iteration += 1 def updateVecs(self): self.vlist[self.currentSize] = self.res.copy() self.cv = self.vlist[self.currentSize] def checkConvergence(self): if self.resnorm < self.tol: if VERBOSE: print("Eigenvalue %3d converged! (res = %.15g)" % (self.ciEig, self.resnorm)) self.ciEig += 1 if self.ciEig == self.nEigen: self.converged = True if self.resnorm < self.tol and not self.converged: if VERBOSE: print("") print("") print("%-3s %-20s %-20s %-8s" % ("#", " Eigenvalue", " Res. Norm.", " Ortho. (should be ~0)")) def gramSchmidtCurrentVec(self,northo): for i in range(northo): self.dgks[i] = np.vdot( self.vlist[i], self.cv ) self.cv -= self.dgks[i]*self.vlist[i] #/ np.vdot(self.vlist[i],self.vlist[i]) self.cv /= np.linalg.norm(self.cv) def checkDeflate(self): if self.currentSize == self.maxM-1: self.deflated = 1 #print "deflating..." for i in range(self.nEigen): self.sol[:self.currentSize] = self.evecs[:self.currentSize,i] # Finds the "best" eigenvector for this eigenvalue self.constructSolV() # Puts this guess in self.Avlist rather than self.vlist for now... # since this would mess up self.constructSolV()'s solution self.Avlist[i] = self.cv.copy() for i in range(self.nEigen): # This is actually the "best" eigenvector v, not A*v (see above) self.cv = self.Avlist[i].copy() self.gramSchmidtCurrentVec(i) self.vlist[i] = self.cv.copy() for i in range(self.nEigen): # This is actually the "best" eigenvector v, not A*v (see above) self.cv = self.vlist[i].copy() # Use current vector cv to create cAv self.hMult() self.Avlist[i] = self.cAv.copy() def constructDeflatedSub(self): if self.deflated == 1: self.currentSize = self.nEigen self.constructSubspace()
sunqm/pyscf
pyscf/pbc/lib/arnoldi.py
Python
apache-2.0
10,549
0.010522
import unittest from datetime import datetime from flask import url_for from app import current_app as app from app.helpers.data import save_to_db from app.models.call_for_papers import CallForPaper from tests.unittests.object_mother import ObjectMother from tests.unittests.utils import OpenEventTestCase class TestGuestEventPage(OpenEventTestCase): def test_published_event_view(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' save_to_db(event, "Event Saved") rv = self.app.get(url_for('event_detail.display_event_detail_home', identifier=event.identifier), follow_redirects=True) self.assertTrue("Open Event" in rv.data, msg=rv.data) def test_published_event_view_coc(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' event.code_of_conduct = 'Test Code of Conduct' save_to_db(event, "Event Saved") rv = self.app.get(url_for('event_detail.display_event_coc', identifier=event.identifier), follow_redirects=True) self.assertTrue("Code of Conduct" in rv.data, msg=rv.data) def test_unpublished_event_view_coc(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' save_to_db(event, "Event Saved") rv = self.app.get(url_for('event_detail.display_event_coc', identifier=event.identifier), follow_redirects=True) self.assertEqual(rv.status_code, 404) def test_unpublished_event_view_attempt(self): with app.test_request_context(): event = ObjectMother.get_event() save_to_db(event, "Event Saved") rv = self.app.get(url_for('event_detail.display_event_detail_home', identifier=event.identifier), follow_redirects=True) self.assertEqual(rv.status_code, 404) def test_soft_deleted_event_view_attempt(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' event.in_trash = True save_to_db(event, "Event Saved") rv = self.app.get(url_for('event_detail.display_event_detail_home', identifier=event.identifier), follow_redirects=True) self.assertEqual(rv.status_code, 404) def test_published_event_sessions_view(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' save_to_db(event, "Event Saved") track = ObjectMother.get_track() track.event_id = event.id save_to_db(track, "Track Saved") speaker = ObjectMother.get_speaker() speaker.event_id = event.id save_to_db(speaker, "Speaker Saved") session = ObjectMother.get_session() session.event_id = event.id session.speakers = [speaker] session.state = 'accepted' save_to_db(session, "Session Saved") rv = self.app.get(url_for('event_detail.display_event_sessions', identifier=event.identifier), follow_redirects=True) self.assertTrue("Sessions" in rv.data, msg=rv.data) def test_published_event_schedule_view(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' event.schedule_published_on = datetime.now() save_to_db(event, "Event Saved") track = ObjectMother.get_track() track.event_id = event.id save_to_db(track, "Track Saved") speaker = ObjectMother.get_speaker() speaker.event_id = event.id save_to_db(speaker, "Speaker Saved") microlocation = ObjectMother.get_microlocation() save_to_db(microlocation, "Microlocation Saved") session = ObjectMother.get_session() session.event_id = event.id session.state = 'accepted' session.microlocation_id = microlocation.id session.speakers = [speaker] save_to_db(session, "Session Saved") rv = self.app.get(url_for('event_detail.display_event_schedule', identifier=event.identifier), follow_redirects=True) self.assertTrue("Schedule" in rv.data, msg=rv.data) def test_published_event_unpublished_schedule_view_attempt(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' save_to_db(event, "Event Saved") track = ObjectMother.get_track() track.event_id = event.id save_to_db(track, "Track Saved") speaker = ObjectMother.get_speaker() speaker.event_id = event.id save_to_db(speaker, "Speaker Saved") microlocation = ObjectMother.get_microlocation() save_to_db(microlocation, "Microlocation Saved") session = ObjectMother.get_session() session.event_id = event.id session.microlocation_id = microlocation.id session.speakers = [speaker] session.state = 'accepted' save_to_db(session, "Session Saved") rv = self.app.get(url_for('event_detail.display_event_schedule', identifier=event.identifier), follow_redirects=True) self.assertEqual(rv.status_code, 404) def test_published_event_cfs_view(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' save_to_db(event, "Event Saved") custom_form = ObjectMother.get_custom_form() custom_form.event_id = event.id save_to_db(custom_form, "Custom form saved") call_for_papers = CallForPaper(announcement="Announce", start_date=datetime(2003, 8, 4, 12, 30, 45), end_date=datetime(2004, 8, 4, 12, 30, 45), event_id=event.id) save_to_db(call_for_papers, "Call for papers saved") rv = self.app.get(url_for('event_detail.display_event_cfs', identifier=event.identifier), follow_redirects=True) self.assertTrue("Closed" in rv.data, msg=rv.data) def test_published_event_cfs_view_attempt(self): with app.test_request_context(): event = ObjectMother.get_event() event.state = 'Published' save_to_db(event, "Event Saved") rv = self.app.get(url_for('event_detail.display_event_cfs', identifier=event.identifier), follow_redirects=True) self.assertEqual(rv.status_code, 404) if __name__ == '__main__': unittest.main()
Achint08/open-event-orga-server
tests/unittests/views/guest/test_guest_event_page.py
Python
gpl-3.0
7,240
0.001657
#!/usr/bin/env python3 # Copyright (c) 2014-2016 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. # # Test replace by fee code # from test_framework.test_framework import ElectrumTestFramework from test_framework.util import * from test_framework.script import * from test_framework.mininode import * MAX_REPLACEMENT_LIMIT = 100 def txToHex(tx): return bytes_to_hex_str(tx.serialize()) def make_utxo(node, amount, confirmed=True, scriptPubKey=CScript([1])): """Create a txout with a given amount and scriptPubKey Mines coins as needed. confirmed - txouts created will be confirmed in the blockchain; unconfirmed otherwise. """ fee = 1*COIN while node.getbalance() < satoshi_round((amount + fee)/COIN): node.generate(100) #print (node.getbalance(), amount, fee) new_addr = node.getnewaddress() #print new_addr txid = node.sendtoaddress(new_addr, satoshi_round((amount+fee)/COIN)) tx1 = node.getrawtransaction(txid, 1) txid = int(txid, 16) i = None for i, txout in enumerate(tx1['vout']): #print i, txout['scriptPubKey']['addresses'] if txout['scriptPubKey']['addresses'] == [new_addr]: #print i break assert i is not None tx2 = CTransaction() tx2.vin = [CTxIn(COutPoint(txid, i))] tx2.vout = [CTxOut(amount, scriptPubKey)] tx2.rehash() signed_tx = node.signrawtransaction(txToHex(tx2)) txid = node.sendrawtransaction(signed_tx['hex'], True) # If requested, ensure txouts are confirmed. if confirmed: mempool_size = len(node.getrawmempool()) while mempool_size > 0: node.generate(1) new_size = len(node.getrawmempool()) # Error out if we have something stuck in the mempool, as this # would likely be a bug. assert(new_size < mempool_size) mempool_size = new_size return COutPoint(int(txid, 16), 0) class ReplaceByFeeTest(ElectrumTestFramework): def setup_network(self): self.nodes = [] self.nodes.append(start_node(0, self.options.tmpdir, ["-maxorphantx=1000", "-debug", "-relaypriority=0", "-whitelist=127.0.0.1", "-limitancestorcount=50", "-limitancestorsize=101", "-limitdescendantcount=200", "-limitdescendantsize=101" ])) self.is_network_split = False def run_test(self): make_utxo(self.nodes[0], 1*COIN) print("Running test simple doublespend...") self.test_simple_doublespend() print("Running test doublespend chain...") self.test_doublespend_chain() print("Running test doublespend tree...") self.test_doublespend_tree() print("Running test replacement feeperkb...") self.test_replacement_feeperkb() print("Running test spends of conflicting outputs...") self.test_spends_of_conflicting_outputs() print("Running test new unconfirmed inputs...") self.test_new_unconfirmed_inputs() print("Running test too many replacements...") self.test_too_many_replacements() print("Running test opt-in...") self.test_opt_in() print("Running test prioritised transactions...") self.test_prioritised_transactions() print("Passed\n") def test_simple_doublespend(self): """Simple doublespend""" tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN)) tx1a = CTransaction() tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1a_hex = txToHex(tx1a) tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True) # Should fail because we haven't changed the fee tx1b = CTransaction() tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1b.vout = [CTxOut(1*COIN, CScript([b'b']))] tx1b_hex = txToHex(tx1b) try: tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) # insufficient fee else: assert(False) # Extra 0.1 ELC fee tx1b = CTransaction() tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1b.vout = [CTxOut(int(0.9*COIN), CScript([b'b']))] tx1b_hex = txToHex(tx1b) tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True) mempool = self.nodes[0].getrawmempool() assert (tx1a_txid not in mempool) assert (tx1b_txid in mempool) assert_equal(tx1b_hex, self.nodes[0].getrawtransaction(tx1b_txid)) def test_doublespend_chain(self): """Doublespend of a long chain""" initial_nValue = 50*COIN tx0_outpoint = make_utxo(self.nodes[0], initial_nValue) prevout = tx0_outpoint remaining_value = initial_nValue chain_txids = [] while remaining_value > 10*COIN: remaining_value -= 1*COIN tx = CTransaction() tx.vin = [CTxIn(prevout, nSequence=0)] tx.vout = [CTxOut(remaining_value, CScript([1]))] tx_hex = txToHex(tx) txid = self.nodes[0].sendrawtransaction(tx_hex, True) chain_txids.append(txid) prevout = COutPoint(int(txid, 16), 0) # Whether the double-spend is allowed is evaluated by including all # child fees - 40 ELC - so this attempt is rejected. dbl_tx = CTransaction() dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)] dbl_tx.vout = [CTxOut(initial_nValue - 30*COIN, CScript([1]))] dbl_tx_hex = txToHex(dbl_tx) try: self.nodes[0].sendrawtransaction(dbl_tx_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) # insufficient fee else: assert(False) # transaction mistakenly accepted! # Accepted with sufficient fee dbl_tx = CTransaction() dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)] dbl_tx.vout = [CTxOut(1*COIN, CScript([1]))] dbl_tx_hex = txToHex(dbl_tx) self.nodes[0].sendrawtransaction(dbl_tx_hex, True) mempool = self.nodes[0].getrawmempool() for doublespent_txid in chain_txids: assert(doublespent_txid not in mempool) def test_doublespend_tree(self): """Doublespend of a big tree of transactions""" initial_nValue = 50*COIN tx0_outpoint = make_utxo(self.nodes[0], initial_nValue) def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _total_txs=None): if _total_txs is None: _total_txs = [0] if _total_txs[0] >= max_txs: return txout_value = (initial_value - fee) // tree_width if txout_value < fee: return vout = [CTxOut(txout_value, CScript([i+1])) for i in range(tree_width)] tx = CTransaction() tx.vin = [CTxIn(prevout, nSequence=0)] tx.vout = vout tx_hex = txToHex(tx) assert(len(tx.serialize()) < 100000) txid = self.nodes[0].sendrawtransaction(tx_hex, True) yield tx _total_txs[0] += 1 txid = int(txid, 16) for i, txout in enumerate(tx.vout): for x in branch(COutPoint(txid, i), txout_value, max_txs, tree_width=tree_width, fee=fee, _total_txs=_total_txs): yield x fee = int(0.0001*COIN) n = MAX_REPLACEMENT_LIMIT tree_txs = list(branch(tx0_outpoint, initial_nValue, n, fee=fee)) assert_equal(len(tree_txs), n) # Attempt double-spend, will fail because too little fee paid dbl_tx = CTransaction() dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)] dbl_tx.vout = [CTxOut(initial_nValue - fee*n, CScript([1]))] dbl_tx_hex = txToHex(dbl_tx) try: self.nodes[0].sendrawtransaction(dbl_tx_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) # insufficient fee else: assert(False) # 1 ELC fee is enough dbl_tx = CTransaction() dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)] dbl_tx.vout = [CTxOut(initial_nValue - fee*n - 1*COIN, CScript([1]))] dbl_tx_hex = txToHex(dbl_tx) self.nodes[0].sendrawtransaction(dbl_tx_hex, True) mempool = self.nodes[0].getrawmempool() for tx in tree_txs: tx.rehash() assert (tx.hash not in mempool) # Try again, but with more total transactions than the "max txs # double-spent at once" anti-DoS limit. for n in (MAX_REPLACEMENT_LIMIT+1, MAX_REPLACEMENT_LIMIT*2): fee = int(0.0001*COIN) tx0_outpoint = make_utxo(self.nodes[0], initial_nValue) tree_txs = list(branch(tx0_outpoint, initial_nValue, n, fee=fee)) assert_equal(len(tree_txs), n) dbl_tx = CTransaction() dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)] dbl_tx.vout = [CTxOut(initial_nValue - 2*fee*n, CScript([1]))] dbl_tx_hex = txToHex(dbl_tx) try: self.nodes[0].sendrawtransaction(dbl_tx_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) assert_equal("too many potential replacements" in exp.error['message'], True) else: assert(False) for tx in tree_txs: tx.rehash() self.nodes[0].getrawtransaction(tx.hash) def test_replacement_feeperkb(self): """Replacement requires fee-per-KB to be higher""" tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN)) tx1a = CTransaction() tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1a_hex = txToHex(tx1a) tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True) # Higher fee, but the fee per KB is much lower, so the replacement is # rejected. tx1b = CTransaction() tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1b.vout = [CTxOut(int(0.001*COIN), CScript([b'a'*999000]))] tx1b_hex = txToHex(tx1b) try: tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) # insufficient fee else: assert(False) def test_spends_of_conflicting_outputs(self): """Replacements that spend conflicting tx outputs are rejected""" utxo1 = make_utxo(self.nodes[0], int(1.2*COIN)) utxo2 = make_utxo(self.nodes[0], 3*COIN) tx1a = CTransaction() tx1a.vin = [CTxIn(utxo1, nSequence=0)] tx1a.vout = [CTxOut(int(1.1*COIN), CScript([b'a']))] tx1a_hex = txToHex(tx1a) tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True) tx1a_txid = int(tx1a_txid, 16) # Direct spend an output of the transaction we're replacing. tx2 = CTransaction() tx2.vin = [CTxIn(utxo1, nSequence=0), CTxIn(utxo2, nSequence=0)] tx2.vin.append(CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)) tx2.vout = tx1a.vout tx2_hex = txToHex(tx2) try: tx2_txid = self.nodes[0].sendrawtransaction(tx2_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) else: assert(False) # Spend tx1a's output to test the indirect case. tx1b = CTransaction() tx1b.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)] tx1b.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1b_hex = txToHex(tx1b) tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True) tx1b_txid = int(tx1b_txid, 16) tx2 = CTransaction() tx2.vin = [CTxIn(utxo1, nSequence=0), CTxIn(utxo2, nSequence=0), CTxIn(COutPoint(tx1b_txid, 0))] tx2.vout = tx1a.vout tx2_hex = txToHex(tx2) try: tx2_txid = self.nodes[0].sendrawtransaction(tx2_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) else: assert(False) def test_new_unconfirmed_inputs(self): """Replacements that add new unconfirmed inputs are rejected""" confirmed_utxo = make_utxo(self.nodes[0], int(1.1*COIN)) unconfirmed_utxo = make_utxo(self.nodes[0], int(0.1*COIN), False) tx1 = CTransaction() tx1.vin = [CTxIn(confirmed_utxo)] tx1.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1_hex = txToHex(tx1) tx1_txid = self.nodes[0].sendrawtransaction(tx1_hex, True) tx2 = CTransaction() tx2.vin = [CTxIn(confirmed_utxo), CTxIn(unconfirmed_utxo)] tx2.vout = tx1.vout tx2_hex = txToHex(tx2) try: tx2_txid = self.nodes[0].sendrawtransaction(tx2_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) else: assert(False) def test_too_many_replacements(self): """Replacements that evict too many transactions are rejected""" # Try directly replacing more than MAX_REPLACEMENT_LIMIT # transactions # Start by creating a single transaction with many outputs initial_nValue = 10*COIN utxo = make_utxo(self.nodes[0], initial_nValue) fee = int(0.0001*COIN) split_value = int((initial_nValue-fee)/(MAX_REPLACEMENT_LIMIT+1)) actual_fee = initial_nValue - split_value*(MAX_REPLACEMENT_LIMIT+1) outputs = [] for i in range(MAX_REPLACEMENT_LIMIT+1): outputs.append(CTxOut(split_value, CScript([1]))) splitting_tx = CTransaction() splitting_tx.vin = [CTxIn(utxo, nSequence=0)] splitting_tx.vout = outputs splitting_tx_hex = txToHex(splitting_tx) txid = self.nodes[0].sendrawtransaction(splitting_tx_hex, True) txid = int(txid, 16) # Now spend each of those outputs individually for i in range(MAX_REPLACEMENT_LIMIT+1): tx_i = CTransaction() tx_i.vin = [CTxIn(COutPoint(txid, i), nSequence=0)] tx_i.vout = [CTxOut(split_value-fee, CScript([b'a']))] tx_i_hex = txToHex(tx_i) self.nodes[0].sendrawtransaction(tx_i_hex, True) # Now create doublespend of the whole lot; should fail. # Need a big enough fee to cover all spending transactions and have # a higher fee rate double_spend_value = (split_value-100*fee)*(MAX_REPLACEMENT_LIMIT+1) inputs = [] for i in range(MAX_REPLACEMENT_LIMIT+1): inputs.append(CTxIn(COutPoint(txid, i), nSequence=0)) double_tx = CTransaction() double_tx.vin = inputs double_tx.vout = [CTxOut(double_spend_value, CScript([b'a']))] double_tx_hex = txToHex(double_tx) try: self.nodes[0].sendrawtransaction(double_tx_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) assert_equal("too many potential replacements" in exp.error['message'], True) else: assert(False) # If we remove an input, it should pass double_tx = CTransaction() double_tx.vin = inputs[0:-1] double_tx.vout = [CTxOut(double_spend_value, CScript([b'a']))] double_tx_hex = txToHex(double_tx) self.nodes[0].sendrawtransaction(double_tx_hex, True) def test_opt_in(self): """ Replacing should only work if orig tx opted in """ tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN)) # Create a non-opting in transaction tx1a = CTransaction() tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0xffffffff)] tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1a_hex = txToHex(tx1a) tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True) # Shouldn't be able to double-spend tx1b = CTransaction() tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1b.vout = [CTxOut(int(0.9*COIN), CScript([b'b']))] tx1b_hex = txToHex(tx1b) try: tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) else: print(tx1b_txid) assert(False) tx1_outpoint = make_utxo(self.nodes[0], int(1.1*COIN)) # Create a different non-opting in transaction tx2a = CTransaction() tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0xfffffffe)] tx2a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx2a_hex = txToHex(tx2a) tx2a_txid = self.nodes[0].sendrawtransaction(tx2a_hex, True) # Still shouldn't be able to double-spend tx2b = CTransaction() tx2b.vin = [CTxIn(tx1_outpoint, nSequence=0)] tx2b.vout = [CTxOut(int(0.9*COIN), CScript([b'b']))] tx2b_hex = txToHex(tx2b) try: tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) else: assert(False) # Now create a new transaction that spends from tx1a and tx2a # opt-in on one of the inputs # Transaction should be replaceable on either input tx1a_txid = int(tx1a_txid, 16) tx2a_txid = int(tx2a_txid, 16) tx3a = CTransaction() tx3a.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0xffffffff), CTxIn(COutPoint(tx2a_txid, 0), nSequence=0xfffffffd)] tx3a.vout = [CTxOut(int(0.9*COIN), CScript([b'c'])), CTxOut(int(0.9*COIN), CScript([b'd']))] tx3a_hex = txToHex(tx3a) self.nodes[0].sendrawtransaction(tx3a_hex, True) tx3b = CTransaction() tx3b.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)] tx3b.vout = [CTxOut(int(0.5*COIN), CScript([b'e']))] tx3b_hex = txToHex(tx3b) tx3c = CTransaction() tx3c.vin = [CTxIn(COutPoint(tx2a_txid, 0), nSequence=0)] tx3c.vout = [CTxOut(int(0.5*COIN), CScript([b'f']))] tx3c_hex = txToHex(tx3c) self.nodes[0].sendrawtransaction(tx3b_hex, True) # If tx3b was accepted, tx3c won't look like a replacement, # but make sure it is accepted anyway self.nodes[0].sendrawtransaction(tx3c_hex, True) def test_prioritised_transactions(self): # Ensure that fee deltas used via prioritisetransaction are # correctly used by replacement logic # 1. Check that feeperkb uses modified fees tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN)) tx1a = CTransaction() tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1a_hex = txToHex(tx1a) tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True) # Higher fee, but the actual fee per KB is much lower. tx1b = CTransaction() tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1b.vout = [CTxOut(int(0.001*COIN), CScript([b'a'*740000]))] tx1b_hex = txToHex(tx1b) # Verify tx1b cannot replace tx1a. try: tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) else: assert(False) # Use prioritisetransaction to set tx1a's fee to 0. self.nodes[0].prioritisetransaction(tx1a_txid, 0, int(-0.1*COIN)) # Now tx1b should be able to replace tx1a tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True) assert(tx1b_txid in self.nodes[0].getrawmempool()) # 2. Check that absolute fee checks use modified fee. tx1_outpoint = make_utxo(self.nodes[0], int(1.1*COIN)) tx2a = CTransaction() tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0)] tx2a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx2a_hex = txToHex(tx2a) tx2a_txid = self.nodes[0].sendrawtransaction(tx2a_hex, True) # Lower fee, but we'll prioritise it tx2b = CTransaction() tx2b.vin = [CTxIn(tx1_outpoint, nSequence=0)] tx2b.vout = [CTxOut(int(1.01*COIN), CScript([b'a']))] tx2b.rehash() tx2b_hex = txToHex(tx2b) # Verify tx2b cannot replace tx2a. try: tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True) except JSONRPCException as exp: assert_equal(exp.error['code'], -26) else: assert(False) # Now prioritise tx2b to have a higher modified fee self.nodes[0].prioritisetransaction(tx2b.hash, 0, int(0.1*COIN)) # tx2b should now be accepted tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True) assert(tx2b_txid in self.nodes[0].getrawmempool()) if __name__ == '__main__': ReplaceByFeeTest().main()
sinraf96/electrum
qa/rpc-tests/replace-by-fee.py
Python
mit
21,883
0.001188
""" Stateful module base class and interface description. All stateful Python modules - Get Skype4Py Skype instance on init - have full control over Skype and thus are not limited to !command handlers - Reside in the some modules/ folder as UNIX script modules - Have .py extension and be valid Python 2.7 modules - Have #!/sevabot magic string at the head of the file - Exports Python attribute *sevabot_handler* which is an instance of the class as described below Please note that in the future we might have different chat backends (GTalk) and thus have a same-same-but-different stateful handlers. """ class StatefulSkypeHandler: """ Base class for stateful handlers. All exceptions slip through are caught and logged. """ def init(self, sevabot): """ Set-up our state. This is called every time module is (re)loaded. You can get Skype4Py instance via ``sevabot.getSkype()``. :param sevabot: Handle to Sevabot instance """ def handle_message(self, msg, status): """Override this method to have a customized handler for each Skype message. :param msg: ChatMessage instance https://github.com/awahlig/skype4py/blob/master/Skype4Py/chat.py#L409 :param status: - :return: True if the message was handled and should not be further processed """ def shutdown(): """ Called when the module is reloaded. In ``shutdown()`` you must * Stop all created threads * Unregister all event handlers ..note :: We do *not* guaranteed to be call when Sevabot process shutdowns as the process may terminate with SIGKILL. """ def register_callback(self, skype, event, callback): """ Register any callable as a callback for a skype event. Thin wrapper for RegisterEventHandler https://github.com/awahlig/skype4py/blob/master/Skype4Py/utils.py :param skype: Skype4Py instance :param event: Same as Event :param callback: Same as Target :return: Same as RegisterEventHandler """ return skype.RegisterEventHandler(event, callback) def unregister_callback(self, skype, event, callback): """ Unregister a callback previously registered with register_callback. Thin wrapper for UnregisterEventHandler https://github.com/awahlig/skype4py/blob/master/Skype4Py/utils.py :param skype: Skype4Py instance :param event: Same as Event :param callback: Same as Target :return: Same as UnregisterEventHandler """ return skype.UnregisterEventHandler(event, callback)
mikemike/SkypeBot
unused-modules/stateful.py
Python
gpl-2.0
2,755
0.004356
# -*- coding: utf-8 -*- ############################################################################## # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # ############################################################################## from openerp import models, fields, exceptions, api, _ import openerp.addons.decimal_precision as dp class PurchaseCostDistribution(models.Model): _name = "purchase.cost.distribution" _description = "Purchase landed costs distribution" _order = 'name desc' @api.one @api.depends('total_expense', 'total_purchase') def _compute_amount_total(self): self.amount_total = self.total_purchase + self.total_expense @api.one @api.depends('cost_lines', 'cost_lines.total_amount') def _compute_total_purchase(self): self.total_purchase = sum([x.total_amount for x in self.cost_lines]) @api.one @api.depends('cost_lines', 'cost_lines.product_price_unit') def _compute_total_price_unit(self): self.total_price_unit = sum([x.product_price_unit for x in self.cost_lines]) @api.one @api.depends('cost_lines', 'cost_lines.product_qty') def _compute_total_uom_qty(self): self.total_uom_qty = sum([x.product_qty for x in self.cost_lines]) @api.one @api.depends('cost_lines', 'cost_lines.total_weight') def _compute_total_weight(self): self.total_weight = sum([x.total_weight for x in self.cost_lines]) @api.one @api.depends('cost_lines', 'cost_lines.total_weight_net') def _compute_total_weight_net(self): self.total_weight_net = sum([x.total_weight_net for x in self.cost_lines]) @api.one @api.depends('cost_lines', 'cost_lines.total_volume') def _compute_total_volume(self): self.total_volume = sum([x.total_volume for x in self.cost_lines]) @api.one @api.depends('expense_lines', 'expense_lines.expense_amount') def _compute_total_expense(self): self.total_expense = sum([x.expense_amount for x in self.expense_lines]) def _expense_lines_default(self): expenses = self.env['purchase.expense.type'].search( [('default_expense', '=', True)]) return [{'type': x, 'expense_amount': x.default_amount} for x in expenses] name = fields.Char(string='Distribution number', required=True, select=True, default='/') company_id = fields.Many2one( comodel_name='res.company', string='Company', required=True, default=(lambda self: self.env['res.company']._company_default_get( 'purchase.cost.distribution'))) currency_id = fields.Many2one( comodel_name='res.currency', string='Currency', related="company_id.currency_id") state = fields.Selection( [('draft', 'Draft'), ('calculated', 'Calculated'), ('done', 'Done'), ('error', 'Error'), ('cancel', 'Cancel')], string='Status', readonly=True, default='draft') cost_update_type = fields.Selection( [('direct', 'Direct Update')], string='Cost Update Type', default='direct', required=True) date = fields.Date( string='Date', required=True, readonly=True, select=True, states={'draft': [('readonly', False)]}, default=fields.Date.context_today) total_uom_qty = fields.Float( compute=_compute_total_uom_qty, readonly=True, digits_compute=dp.get_precision('Product UoS'), string='Total quantity') total_weight = fields.Float( compute=_compute_total_weight, string='Total gross weight', readonly=True, digits_compute=dp.get_precision('Stock Weight')) total_weight_net = fields.Float( compute=_compute_total_weight_net, digits_compute=dp.get_precision('Stock Weight'), string='Total net weight', readonly=True) total_volume = fields.Float( compute=_compute_total_volume, string='Total volume', readonly=True) total_purchase = fields.Float( compute=_compute_total_purchase, digits_compute=dp.get_precision('Account'), string='Total purchase') total_price_unit = fields.Float( compute=_compute_total_price_unit, string='Total price unit', digits_compute=dp.get_precision('Product Price')) amount_total = fields.Float( compute=_compute_amount_total, digits_compute=dp.get_precision('Account'), string='Total') total_expense = fields.Float( compute=_compute_total_expense, digits_compute=dp.get_precision('Account'), string='Total expenses') note = fields.Text(string='Documentation for this order') cost_lines = fields.One2many( comodel_name='purchase.cost.distribution.line', ondelete="cascade", inverse_name='distribution', string='Distribution lines') expense_lines = fields.One2many( comodel_name='purchase.cost.distribution.expense', ondelete="cascade", inverse_name='distribution', string='Expenses', default=_expense_lines_default) @api.multi def unlink(self): for c in self: if c.state not in ('draft', 'calculated'): raise exceptions.Warning( _("You can't delete a confirmed cost distribution")) return super(PurchaseCostDistribution, self).unlink() @api.model def create(self, vals): if vals.get('name', '/') == '/': vals['name'] = self.env['ir.sequence'].next_by_code( 'purchase.cost.distribution') return super(PurchaseCostDistribution, self).create(vals) @api.multi def action_calculate(self): for distribution in self: # Check expense lines for amount 0 if any([not x.expense_amount for x in distribution.expense_lines]): raise exceptions.Warning( _('Please enter an amount for all the expenses')) # Check if exist lines in distribution if not distribution.cost_lines: raise exceptions.Warning( _('There is no picking lines in the distribution')) # Calculating expense line for line in distribution.cost_lines: line.expense_lines.unlink() for expense in distribution.expense_lines: if (expense.affected_lines and line.id not in expense.affected_lines.ids): continue if expense.type.calculation_method == 'amount': multiplier = line.total_amount if expense.affected_lines: divisor = sum([x.total_amount for x in expense.affected_lines]) else: divisor = distribution.total_purchase elif expense.type.calculation_method == 'price': multiplier = line.product_price_unit if expense.affected_lines: divisor = sum([x.product_price_unit for x in expense.affected_lines]) else: divisor = distribution.total_price_unit elif expense.type.calculation_method == 'qty': multiplier = line.product_qty if expense.affected_lines: divisor = sum([x.product_qty for x in expense.affected_lines]) else: divisor = distribution.total_uom_qty elif expense.type.calculation_method == 'weight': multiplier = line.total_weight if expense.affected_lines: divisor = sum([x.total_weight for x in expense.affected_lines]) else: divisor = distribution.total_weight elif expense.type.calculation_method == 'weight_net': multiplier = line.total_weight_net if expense.affected_lines: divisor = sum([x.total_weight_net for x in expense.affected_lines]) else: divisor = distribution.total_weight_net elif expense.type.calculation_method == 'volume': multiplier = line.total_volume if expense.affected_lines: divisor = sum([x.total_volume for x in expense.affected_lines]) else: divisor = distribution.total_volume elif expense.type.calculation_method == 'equal': multiplier = 1 divisor = (len(expense.affected_lines) or len(distribution.cost_lines)) else: raise exceptions.Warning( _('No valid distribution type.')) expense_amount = (expense.expense_amount * multiplier / divisor) expense_line = { 'distribution_expense': expense.id, 'expense_amount': expense_amount, 'cost_ratio': expense_amount / line.product_qty, } line.expense_lines = [(0, 0, expense_line)] distribution.state = 'calculated' return True def _product_price_update(self, move, new_price): """Method that mimicks stock.move's product_price_update_before_done method behaviour, but taking into account that calculations are made on an already done move, and prices sources are given as parameters. """ if (move.location_id.usage == 'supplier' and move.product_id.cost_method == 'average'): product = move.product_id qty_available = product.product_tmpl_id.qty_available product_avail = qty_available - move.product_qty if product_avail <= 0: new_std_price = move.price_unit else: domain_quant = [ ('product_id', 'in', product.product_tmpl_id.product_variant_ids.ids), ('id', 'not in', move.quant_ids.ids)] quants = self.env['stock.quant'].read_group( domain_quant, ['product_id', 'qty', 'cost'], [])[0] # Get the standard price new_std_price = ((quants['cost'] * quants['qty'] + new_price * move.product_qty) / qty_available) # Write the standard price, as SUPERUSER_ID, because a # warehouse manager may not have the right to write on products product.sudo().write({'standard_price': new_std_price}) @api.one def action_done(self): for line in self.cost_lines: if self.cost_update_type == 'direct': line.move_id.quant_ids._price_update(line.standard_price_new) self._product_price_update(line.move_id, line.standard_price_new) line.move_id.product_price_update_after_done() self.state = 'done' @api.multi def action_draft(self): self.write({'state': 'draft'}) return True @api.one def action_cancel(self): for line in self.cost_lines: if self.cost_update_type == 'direct': if self.currency_id.compare_amounts( line.move_id.quant_ids[0].cost, line.standard_price_new) != 0: raise exceptions.Warning( _('Cost update cannot be undone because there has ' 'been a later update. Restore correct price and try ' 'again.')) line.move_id.quant_ids._price_update(line.standard_price_old) self._product_price_update( line.move_id, line.standard_price_old) line.move_id.product_price_update_after_done() self.state = 'draft' class PurchaseCostDistributionLine(models.Model): _name = "purchase.cost.distribution.line" _description = "Purchase cost distribution Line" _rec_name = 'picking_id' @api.one @api.depends('product_price_unit', 'product_qty') def _compute_total_amount(self): self.total_amount = self.product_price_unit * self.product_qty @api.one @api.depends('product_id', 'product_qty') def _compute_total_weight(self): self.total_weight = self.product_weight * self.product_qty @api.one @api.depends('product_id', 'product_qty') def _compute_total_weight_net(self): self.total_weight_net = self.product_weight_net * self.product_qty @api.one @api.depends('product_id', 'product_qty') def _compute_total_volume(self): self.total_volume = self.product_volume * self.product_qty @api.one @api.depends('expense_lines', 'expense_lines.cost_ratio') def _compute_cost_ratio(self): self.cost_ratio = sum([x.cost_ratio for x in self.expense_lines]) @api.one @api.depends('expense_lines', 'expense_lines.expense_amount') def _compute_expense_amount(self): self.expense_amount = sum([x.expense_amount for x in self.expense_lines]) @api.one @api.depends('standard_price_old', 'cost_ratio') def _compute_standard_price_new(self): self.standard_price_new = self.standard_price_old + self.cost_ratio @api.one @api.depends('move_id', 'move_id.picking_id', 'move_id.product_id', 'move_id.product_qty') def _compute_display_name(self): self.name = '%s / %s / %s' % ( self.move_id.picking_id.name, self.move_id.product_id.display_name, self.move_id.product_qty) @api.one @api.depends('move_id', 'move_id.product_id') def _get_product_id(self): # Cannot be done via related field due to strange bug in update chain self.product_id = self.move_id.product_id.id @api.one @api.depends('move_id', 'move_id.product_qty') def _get_product_qty(self): # Cannot be done via related field due to strange bug in update chain self.product_qty = self.move_id.product_qty @api.one @api.depends('move_id') def _get_standard_price_old(self): self.standard_price_old = ( self.move_id and self.move_id.get_price_unit(self.move_id) or 0.0) name = fields.Char( string='Name', compute='_compute_display_name') distribution = fields.Many2one( comodel_name='purchase.cost.distribution', string='Cost distribution', ondelete='cascade') move_id = fields.Many2one( comodel_name='stock.move', string='Picking line', ondelete="restrict") purchase_line_id = fields.Many2one( comodel_name='purchase.order.line', string='Purchase order line', related='move_id.purchase_line_id') purchase_id = fields.Many2one( comodel_name='purchase.order', string='Purchase order', readonly=True, related='move_id.purchase_line_id.order_id', store=True) partner = fields.Many2one( comodel_name='res.partner', string='Supplier', readonly=True, related='move_id.purchase_line_id.order_id.partner_id') picking_id = fields.Many2one( 'stock.picking', string='Picking', related='move_id.picking_id', store=True) product_id = fields.Many2one( comodel_name='product.product', string='Product', store=True, compute='_get_product_id') product_qty = fields.Float( string='Quantity', compute='_get_product_qty', store=True) product_uom = fields.Many2one( comodel_name='product.uom', string='Unit of measure', related='move_id.product_uom') product_uos_qty = fields.Float( string='Quantity (UoS)', related='move_id.product_uos_qty') product_uos = fields.Many2one( comodel_name='product.uom', string='Product UoS', related='move_id.product_uos') product_price_unit = fields.Float( string='Unit price', related='move_id.price_unit') expense_lines = fields.One2many( comodel_name='purchase.cost.distribution.line.expense', inverse_name='distribution_line', string='Expenses distribution lines', ondelete='cascade') product_volume = fields.Float( string='Volume', help="The volume in m3.", related='product_id.product_tmpl_id.volume') product_weight = fields.Float( string='Gross weight', related='product_id.product_tmpl_id.weight', help="The gross weight in Kg.") product_weight_net = fields.Float( string='Net weight', related='product_id.product_tmpl_id.weight_net', help="The net weight in Kg.") standard_price_old = fields.Float( string='Previous cost', compute="_get_standard_price_old", store=True, digits_compute=dp.get_precision('Product Price')) expense_amount = fields.Float( string='Cost amount', digits_compute=dp.get_precision('Account'), compute='_compute_expense_amount') cost_ratio = fields.Float( string='Unit cost', digits_compute=dp.get_precision('Account'), compute='_compute_cost_ratio') standard_price_new = fields.Float( string='New cost', digits_compute=dp.get_precision('Product Price'), compute='_compute_standard_price_new') total_amount = fields.Float( compute=_compute_total_amount, string='Amount line', digits_compute=dp.get_precision('Account')) total_weight = fields.Float( compute=_compute_total_weight, string="Line weight", store=True, digits_compute=dp.get_precision('Stock Weight'), help="The line gross weight in Kg.") total_weight_net = fields.Float( compute=_compute_total_weight_net, string='Line net weight', digits_compute=dp.get_precision('Stock Weight'), store=True, help="The line net weight in Kg.") total_volume = fields.Float( compute=_compute_total_volume, string='Line volume', store=True, help="The line volume in m3.") class PurchaseCostDistributionLineExpense(models.Model): _name = "purchase.cost.distribution.line.expense" _description = "Purchase cost distribution line expense" distribution_line = fields.Many2one( comodel_name='purchase.cost.distribution.line', string='Cost distribution line', ondelete="cascade") distribution_expense = fields.Many2one( comodel_name='purchase.cost.distribution.expense', string='Distribution expense', ondelete="cascade") type = fields.Many2one( 'purchase.expense.type', string='Expense type', related='distribution_expense.type') expense_amount = fields.Float( string='Expense amount', default=0.0, digits_compute=dp.get_precision('Account')) cost_ratio = fields.Float( 'Unit cost', default=0.0, digits_compute=dp.get_precision('Account')) class PurchaseCostDistributionExpense(models.Model): _name = "purchase.cost.distribution.expense" _description = "Purchase cost distribution expense" _rec_name = "type" @api.one @api.depends('distribution', 'distribution.cost_lines') def _get_imported_lines(self): self.imported_lines = self.env['purchase.cost.distribution.line'] self.imported_lines |= self.distribution.cost_lines distribution = fields.Many2one( comodel_name='purchase.cost.distribution', string='Cost distribution', select=True, ondelete="cascade", required=True) ref = fields.Char(string="Reference") type = fields.Many2one( comodel_name='purchase.expense.type', string='Expense type', select=True, ondelete="restrict") calculation_method = fields.Selection( string='Calculation method', related='type.calculation_method', readonly=True) imported_lines = fields.Many2many( comodel_name='purchase.cost.distribution.line', string='Imported lines', compute='_get_imported_lines') affected_lines = fields.Many2many( comodel_name='purchase.cost.distribution.line', column1="expense_id", relation="distribution_expense_aff_rel", column2="line_id", string='Affected lines', help="Put here specific lines that this expense is going to be " "distributed across. Leave it blank to use all imported lines.", domain="[('id', 'in', imported_lines[0][2])]") expense_amount = fields.Float( string='Expense amount', digits_compute=dp.get_precision('Account'), required=True) invoice_line = fields.Many2one( comodel_name='account.invoice.line', string="Supplier invoice line", domain="[('invoice_id.type', '=', 'in_invoice')," "('invoice_id.state', 'in', ('open', 'paid'))]") @api.onchange('type') def onchange_type(self): if self.type and self.type.default_amount: self.expense_amount = self.type.default_amount
MarcosCommunity/odoo
comunity_modules/purchase_landed_cost/models/purchase_cost_distribution.py
Python
agpl-3.0
22,280
0.00009
import argparse from selenium import webdriver from selenium.webdriver.support.wait import WebDriverWait from selenium.webdriver.support import expected_conditions as ec from selenium.webdriver.common.by import By import time import socket import os import os.path from pathlib import Path def clean(file): try: os.remove(file) except OSError: pass def chrome(url, video_name, wait_timeout): capabilities = { "browserName": "chrome", "version": "84.0", "enableVNC": True, "enableVideo": True, "videoName": video_name } chrome = webdriver.Remote(command_executor='http://selenoid:4444/wd/hub', desired_capabilities=capabilities) chrome.set_window_rect(-4, -125, 1928, 1208) # this is needed since Chrome has not docs entry host in loaded /etc/hosts fixed_url = url.replace('docs', socket.gethostbyname('docs')) print('Opening Chrome on '+fixed_url) chrome.get(fixed_url) #chrome.find_element_by_css_selector('body').send_keys('f') WebDriverWait(chrome, wait_timeout).until(ec.visibility_of_element_located((By.CSS_SELECTOR, '.the-end'))) chrome.quit() def wait_until_video_is_exported(file, timeout): time_counter = 0 while not os.path.exists(file): time.sleep(1) time_counter += 1 if time_counter > timeout:break if __name__ == "__main__": parser = argparse.ArgumentParser(description='Run chrome browser on provided url.') parser.add_argument('url') parser.add_argument('--slide-end-timeout', default=300) parser.add_argument('--recorded-video', default='/tmp/showcase.mp4') parser.add_argument('--recorded-video-timeout', default=120) args = parser.parse_args() clean(args.recorded_video) chrome(args.url, Path(args.recorded_video).name, args.slide_end_timeout) # wait for video to be ready and renamed wait_until_video_is_exported(args.recorded_video, args.recorded_video_timeout)
groupe-sii/ogham
.tools/showcase-recorder/showcase-launcher/play_showcase.py
Python
apache-2.0
2,008
0.005976
# -*- coding: utf-8 -*- import datetime from django.shortcuts import render from django.utils.timezone import now from django.utils.translation import ugettext_lazy as _ def home(request): today = datetime.date.today() return render(request, "taskbuster/index.html", {'today': today, 'now': now()}) def home_files(request, filename): return render(request, filename, {}, content_type="text/plain")
caithess/taskbuster
taskbuster/views.py
Python
mit
451
0
# coding=utf-8 # Copyright 2022 The Tensor2Tensor Authors. # # 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. """Miscellaneous utilities.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import pprint import re # Camel case to snake case utils _first_cap_re = re.compile("(.)([A-Z][a-z0-9]+)") _all_cap_re = re.compile("([a-z0-9])([A-Z])") def camelcase_to_snakecase(name): s1 = _first_cap_re.sub(r"\1_\2", name) return _all_cap_re.sub(r"\1_\2", s1).lower() def snakecase_to_camelcase(name): return "".join([w[0].upper() + w[1:] for w in name.split("_")]) def pprint_hparams(hparams): """Represents hparams using its dictionary and calls pprint.pformat on it.""" return "\n{}".format(pprint.pformat(hparams.values(), width=1))
tensorflow/tensor2tensor
tensor2tensor/utils/misc_utils.py
Python
apache-2.0
1,305
0.003831
import sys import copy DEBUG = False ROOM_SIZE = 10 LIGHT_DISTRIBUTION = 20 class Point(object): def __init__(self, row, col): self.row = row self.col = col def __eq__(self, other): return self.row == other.row and self.col == other.col def __str__(self): return "(%i,%i)" % (self.row, self.col) class Element(object): WALL = '#' COLUMN = 'o' PRISM = '*' EMPTY = ' ' LIGHT_X = 'X' LIGHT_BACK = '\\' LIGHT_FORWARD = '/' class Trajectory(object): UP_L = 0 UP_R = 1 DN_L = 2 DN_R = 3 ALL = [0, 1, 2, 3] @staticmethod def reverse(trajectory): return { Trajectory.UP_L: Trajectory.DN_R, Trajectory.UP_R: Trajectory.DN_L, Trajectory.DN_L: Trajectory.UP_R, Trajectory.DN_R: Trajectory.UP_L } [trajectory] @staticmethod def reflect_vertical(trajectory): return { Trajectory.UP_L: Trajectory.UP_R, Trajectory.UP_R: Trajectory.UP_L, Trajectory.DN_L: Trajectory.DN_R, Trajectory.DN_R: Trajectory.DN_L } [trajectory] @staticmethod def reflect_horizontal(trajectory): return { Trajectory.UP_L: Trajectory.DN_L, Trajectory.UP_R: Trajectory.DN_R, Trajectory.DN_L: Trajectory.UP_L, Trajectory.DN_R: Trajectory.UP_R } [trajectory] class Ray(object): def __init__(self, position, trajectory, intensity): self.position = position self.trajectory = trajectory self.intensity = intensity def __str__(self): return "Ray: {%s, %s, %i}" % (self.position, self.trajectory, self.intensity) class Room(object): def __init__(self, schematic): self.schematic = schematic def __str__(self): delimiter = '\n' if DEBUG else '' return delimiter.join(''.join(x) for x in self.schematic) def _get_element(self, point): return self.schematic[point.row][point.col] def _set_element(self, point, trajectory): element = self._get_element(point) if trajectory == Trajectory.UP_R or trajectory == Trajectory.DN_L: # Forward slash self.schematic[point.row][point.col] = { ' ': '/', '/': '/', '\\': 'X', 'X': 'X' } [element] else: # Back slash self.schematic[point.row][point.col] = { ' ': '\\', '/': 'X', '\\': '\\', 'X': 'X' } [element] @property def _hole(self): # Top and bottom rows. for c in range(0, ROOM_SIZE): if self._get_element(Point(0, c)) != Element.WALL: return Point(0, c) if self._get_element(Point(ROOM_SIZE-1, c)) != Element.WALL: return Point(ROOM_SIZE-1, c) # Sides for r in range(1, ROOM_SIZE-1): if self._get_element(Point(r, 0)) != Element.WALL: return Point(r, 0) if self._get_element(Point(r, ROOM_SIZE-1)) != Element.WALL: return Point(r, ROOM_SIZE-1) # Should never reach here given valid input. return None @property def _initial_trajectory(self): hole = self._hole hole_element = self._get_element(hole) # Top. if hole.row == 0: return Trajectory.DN_L if hole_element == Element.LIGHT_FORWARD else Trajectory.DN_R # Bottom. if hole.row == ROOM_SIZE-1: return Trajectory.UP_R if hole_element == Element.LIGHT_FORWARD else Trajectory.UP_L # Left. if hole.col == 0: return Trajectory.UP_R if hole_element == Element.LIGHT_FORWARD else Trajectory.DN_R # Right. if hole.col == ROOM_SIZE-1: return Trajectory.DN_L if hole_element == Element.LIGHT_FORWARD else Trajectory.UP_L # Should never reach this point. return None @staticmethod def _next_position(current_position, trajectory): return { Trajectory.UP_L: Point(current_position.row-1, current_position.col-1), Trajectory.UP_R: Point(current_position.row-1, current_position.col+1), Trajectory.DN_L: Point(current_position.row+1, current_position.col-1), Trajectory.DN_R: Point(current_position.row+1, current_position.col+1) } [trajectory] @staticmethod def _is_corner(point): corners = [Point(0, 0), Point(0, ROOM_SIZE-1), Point(ROOM_SIZE-1, 0), Point(ROOM_SIZE-1, ROOM_SIZE-1)] return point in corners @staticmethod def _is_in_room(point): return 0 <= point.col < ROOM_SIZE and 0 <= point.row < ROOM_SIZE @staticmethod def _is_on_wall(point): return point.row == 0 or point.row == ROOM_SIZE-1 or point.col == 0 or point.col == ROOM_SIZE-1 def _propagate_light(self, rays): result = [] for ray in rays: new_rays = [] next_position = Room._next_position(ray.position, ray.trajectory) if not self._is_in_room(next_position): continue next_element = self._get_element(next_position) if next_element == Element.WALL: if not Room._is_corner(next_position): # Left wall. if next_position.col == 0: row = next_position.row col = next_position.col + 1 trajectory = Trajectory.reflect_vertical(ray.trajectory) # Right wall. elif next_position.col == ROOM_SIZE-1: row = next_position.row col = next_position.col - 1 trajectory = Trajectory.reflect_vertical(ray.trajectory) # Top wall. elif next_position.row == 0: row = next_position.row + 1 col = next_position.col trajectory = Trajectory.reflect_horizontal(ray.trajectory) # Bottom wall. else: row = next_position.row -1 col = next_position.col trajectory = Trajectory.reflect_horizontal(ray.trajectory) next_position = Point(row, col) self._set_element(next_position, trajectory) new_rays.append(Ray(next_position, trajectory, ray.intensity-1)) elif next_element == Element.COLUMN: # The ray hit a hole; kill it off. pass elif next_element == Element.PRISM: # The ray hit a prism; create three new rays. trajectories = copy.deepcopy(Trajectory.ALL) trajectories.remove(Trajectory.reverse(ray.trajectory)) for trajectory in trajectories: new_rays.append(Ray(next_position, trajectory, ray.intensity)) elif next_element == Element.EMPTY or \ next_element == Element.LIGHT_X or \ next_element == Element.LIGHT_BACK or \ next_element == Element.LIGHT_FORWARD: new_rays.append(Ray(next_position, ray.trajectory, ray.intensity-1)) self._set_element(next_position, ray.trajectory) # Eliminate ray if it has lost its intensity. for new_ray in new_rays: if new_ray.intensity > 0: result.append(new_ray) return result def propagate_light(self): rays = [Ray(self._hole, self._initial_trajectory, LIGHT_DISTRIBUTION-1)] while len(rays) > 0: rays = self._propagate_light(rays) def main(): test_cases = open(sys.argv[1], 'r') for test in test_cases: test = test.strip() if len(test) == 0: continue room = Room([list(t) for t in zip(*[iter(test)]*ROOM_SIZE)]) if DEBUG: print('---\n' + str(room)) room.propagate_light() print(room) test_cases.close() if __name__ == '__main__': main()
mpillar/codeeval
2-hard/ray-of-light/main.py
Python
unlicense
8,179
0.005502
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations class Migration(migrations.Migration): dependencies = [ ('applications', '0003_auto_20150115_1330'), ] operations = [ migrations.RenameField( model_name='applicationtask', old_name='title', new_name='name', ), ]
HackBulgaria/Odin
applications/migrations/0004_auto_20150115_1340.py
Python
agpl-3.0
398
0
from fastapi import FastAPI from fastapi.responses import RedirectResponse app = FastAPI() @app.get("/typer") async def redirect_typer(): return RedirectResponse("https://typer.tiangolo.com")
tiangolo/fastapi
docs_src/custom_response/tutorial006.py
Python
mit
199
0
""" None of the functions/objects in this module need be passed `db`. Naming convention: a `pub` is either a pubkey or a pubkeyhash """ import hashlib import bitcoin as bitcoinlib import binascii from bitcoin.core.key import CPubKey from counterpartylib.lib import util from counterpartylib.lib import config from counterpartylib.lib import exceptions b58_digits = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' class InputError (Exception): pass class AddressError(Exception): pass class MultiSigAddressError(AddressError): pass class VersionByteError (AddressError): pass class Base58Error (AddressError): pass class Base58ChecksumError (Base58Error): pass def validate(address): """Make sure the address is valid. May throw `AddressError`. """ # Get array of pubkeyhashes to check. if is_multisig(address): pubkeyhashes = pubkeyhash_array(address) else: pubkeyhashes = [address] # Check validity by attempting to decode. for pubkeyhash in pubkeyhashes: base58_check_decode(pubkeyhash, config.ADDRESSVERSION) def base58_encode(binary): """Encode the address in base58.""" # Convert big‐endian bytes to integer n = int('0x0' + util.hexlify(binary), 16) # Divide that integer into base58 res = [] while n > 0: n, r = divmod(n, 58) res.append(b58_digits[r]) res = ''.join(res[::-1]) return res def base58_check_encode(original, version): """Check if base58 encoding is valid.""" b = binascii.unhexlify(bytes(original, 'utf-8')) d = version + b binary = d + util.dhash(d)[:4] res = base58_encode(binary) # Encode leading zeros as base58 zeros czero = 0 pad = 0 for c in d: if c == czero: pad += 1 else: break address = b58_digits[0] * pad + res if original != util.hexlify(base58_check_decode(address, version)): raise AddressError('encoded address does not decode properly') return address def base58_check_decode(s, version): """Decode from base58.""" # Convert the string to an integer n = 0 for c in s: n *= 58 if c not in b58_digits: raise Base58Error('Not a valid Base58 character: ‘{}’'.format(c)) digit = b58_digits.index(c) n += digit # Convert the integer to bytes h = '%x' % n if len(h) % 2: h = '0' + h res = binascii.unhexlify(h.encode('utf8')) # Add padding back. pad = 0 for c in s[:-1]: if c == b58_digits[0]: pad += 1 else: break k = version * pad + res addrbyte, data, chk0 = k[0:1], k[1:-4], k[-4:] if addrbyte != version: raise VersionByteError('incorrect version byte') chk1 = util.dhash(addrbyte + data)[:4] if chk0 != chk1: raise Base58ChecksumError('Checksum mismatch: 0x{} ≠ 0x{}'.format(util.hexlify(chk0), util.hexlify(chk1))) return data def is_multisig(address): """Check if the address is multi‐signature.""" array = address.split('_') return len(array) > 1 def is_fully_valid(pubkey_bin): """Check if the public key is valid.""" cpubkey = CPubKey(pubkey_bin) return cpubkey.is_fullyvalid def make_canonical(address): """Return canonical version of the address.""" if is_multisig(address): signatures_required, pubkeyhashes, signatures_possible = extract_array(address) try: [base58_check_decode(pubkeyhash, config.ADDRESSVERSION) for pubkeyhash in pubkeyhashes] except Base58Error: raise MultiSigAddressError('Multi‐signature address must use PubKeyHashes, not public keys.') return construct_array(signatures_required, pubkeyhashes, signatures_possible) else: return address def test_array(signatures_required, pubs, signatures_possible): """Check if multi‐signature data is valid.""" try: signatures_required, signatures_possible = int(signatures_required), int(signatures_possible) except (ValueError, TypeError): raise MultiSigAddressError('Signature values not integers.') if signatures_required < 1 or signatures_required > 3: raise MultiSigAddressError('Invalid signatures_required.') if signatures_possible < 2 or signatures_possible > 3: raise MultiSigAddressError('Invalid signatures_possible.') for pubkey in pubs: if '_' in pubkey: raise MultiSigAddressError('Invalid characters in pubkeys/pubkeyhashes.') if signatures_possible != len(pubs): raise InputError('Incorrect number of pubkeys/pubkeyhashes in multi‐signature address.') def construct_array(signatures_required, pubs, signatures_possible): """Create a multi‐signature address.""" test_array(signatures_required, pubs, signatures_possible) address = '_'.join([str(signatures_required)] + sorted(pubs) + [str(signatures_possible)]) return address def extract_array(address): """Extract data from multi‐signature address.""" assert is_multisig(address) array = address.split('_') signatures_required, pubs, signatures_possible = array[0], sorted(array[1:-1]), array[-1] test_array(signatures_required, pubs, signatures_possible) return int(signatures_required), pubs, int(signatures_possible) def pubkeyhash_array(address): """Return PubKeyHashes from an address.""" signatures_required, pubs, signatures_possible = extract_array(address) if not all([is_pubkeyhash(pub) for pub in pubs]): raise MultiSigAddressError('Invalid PubKeyHashes. Multi‐signature address must use PubKeyHashes, not public keys.') pubkeyhashes = pubs return pubkeyhashes def hash160(x): x = hashlib.sha256(x).digest() m = hashlib.new('ripemd160') m.update(x) return m.digest() def pubkey_to_pubkeyhash(pubkey): """Convert public key to PubKeyHash.""" pubkeyhash = hash160(pubkey) pubkey = base58_check_encode(binascii.hexlify(pubkeyhash).decode('utf-8'), config.ADDRESSVERSION) return pubkey def get_asm(scriptpubkey): # TODO: When is an exception thrown here? Can this `try` block be tighter? Can it be replaced by a conditional? try: asm = [] # TODO: This should be `for element in scriptpubkey`. for op in scriptpubkey: if type(op) == bitcoinlib.core.script.CScriptOp: # TODO: `op = element` asm.append(str(op)) else: # TODO: `data = element` (?) asm.append(op) except bitcoinlib.core.script.CScriptTruncatedPushDataError: raise exceptions.DecodeError('invalid pushdata due to truncation') if not asm: raise exceptions.DecodeError('empty output') return asm def get_checksig(asm): if len(asm) == 5 and asm[0] == 'OP_DUP' and asm[1] == 'OP_HASH160' and asm[3] == 'OP_EQUALVERIFY' and asm[4] == 'OP_CHECKSIG': pubkeyhash = asm[2] if type(pubkeyhash) == bytes: return pubkeyhash raise exceptions.DecodeError('invalid OP_CHECKSIG') def get_checkmultisig(asm): # N‐of‐2 if len(asm) == 5 and asm[3] == 2 and asm[4] == 'OP_CHECKMULTISIG': pubkeys, signatures_required = asm[1:3], asm[0] if all([type(pubkey) == bytes for pubkey in pubkeys]): return pubkeys, signatures_required # N‐of‐3 if len(asm) == 6 and asm[4] == 3 and asm[5] == 'OP_CHECKMULTISIG': pubkeys, signatures_required = asm[1:4], asm[0] if all([type(pubkey) == bytes for pubkey in pubkeys]): return pubkeys, signatures_required raise exceptions.DecodeError('invalid OP_CHECKMULTISIG') def scriptpubkey_to_address(scriptpubkey): asm = get_asm(scriptpubkey) if asm[-1] == 'OP_CHECKSIG': try: checksig = get_checksig(asm) except exceptions.DecodeError: # coinbase return None return base58_check_encode(binascii.hexlify(checksig).decode('utf-8'), config.ADDRESSVERSION) elif asm[-1] == 'OP_CHECKMULTISIG': pubkeys, signatures_required = get_checkmultisig(asm) pubkeyhashes = [pubkey_to_pubkeyhash(pubkey) for pubkey in pubkeys] return construct_array(signatures_required, pubkeyhashes, len(pubkeyhashes)) return None # TODO: Use `python-bitcointools` instead. (Get rid of `pycoin` dependency.) from pycoin.encoding import wif_to_tuple_of_secret_exponent_compressed, public_pair_to_sec, EncodingError from pycoin.ecdsa import generator_secp256k1, public_pair_for_secret_exponent class AltcoinSupportError (Exception): pass def private_key_to_public_key(private_key_wif): """Convert private key to public key.""" if config.TESTNET: allowable_wif_prefixes = [config.PRIVATEKEY_VERSION_TESTNET] else: allowable_wif_prefixes = [config.PRIVATEKEY_VERSION_MAINNET] try: secret_exponent, compressed = wif_to_tuple_of_secret_exponent_compressed( private_key_wif, allowable_wif_prefixes=allowable_wif_prefixes) except EncodingError: raise AltcoinSupportError('pycoin: unsupported WIF prefix') public_pair = public_pair_for_secret_exponent(generator_secp256k1, secret_exponent) public_key = public_pair_to_sec(public_pair, compressed=compressed) public_key_hex = binascii.hexlify(public_key).decode('utf-8') return public_key_hex def is_pubkeyhash(monosig_address): """Check if PubKeyHash is valid. """ assert not is_multisig(monosig_address) try: base58_check_decode(monosig_address, config.ADDRESSVERSION) return True except (Base58Error, VersionByteError): return False def make_pubkeyhash(address): """Create a new PubKeyHash.""" if is_multisig(address): signatures_required, pubs, signatures_possible = extract_array(address) pubkeyhashes = [] for pub in pubs: if is_pubkeyhash(pub): pubkeyhash = pub else: pubkeyhash = pubkey_to_pubkeyhash(binascii.unhexlify(bytes(pub, 'utf-8'))) pubkeyhashes.append(pubkeyhash) pubkeyhash_address = construct_array(signatures_required, pubkeyhashes, signatures_possible) else: if is_pubkeyhash(address): pubkeyhash_address = address else: pubkeyhash_address = pubkey_to_pubkeyhash(binascii.unhexlify(bytes(address, 'utf-8'))) return pubkeyhash_address def extract_pubkeys(pub): """Assume pubkey if not pubkeyhash. (Check validity later.)""" pubkeys = [] if is_multisig(pub): _, pubs, _ = extract_array(pub) for pub in pubs: if not is_pubkeyhash(pub): pubkeys.append(pub) else: if not is_pubkeyhash(pub): pubkeys.append(pub) return pubkeys # vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
tokenly/counterparty-lib
counterpartylib/lib/script.py
Python
mit
10,947
0.00513
"""Image class. Represents an image in the frontend using a widget. """ # Copyright (c) Jupyter Development Team. # Distributed under the terms of the Modified BSD License. import base64 from .domwidget import DOMWidget from .widget import register from traitlets import Unicode, CUnicode, Bytes, observe @register('Jupyter.Image') class Image(DOMWidget): """Displays an image as a widget. The `value` of this widget accepts a byte string. The byte string is the raw image data that you want the browser to display. You can explicitly define the format of the byte string using the `format` trait (which defaults to "png"). """ _view_name = Unicode('ImageView').tag(sync=True) _model_name = Unicode('ImageModel').tag(sync=True) _model_module = Unicode('jupyter-js-widgets').tag(sync=True) _view_module = Unicode('jupyter-js-widgets').tag(sync=True) # Define the custom state properties to sync with the front-end format = Unicode('png').tag(sync=True) width = CUnicode().tag(sync=True) height = CUnicode().tag(sync=True) _b64value = Unicode().tag(sync=True) value = Bytes() @observe('value') def _value_changed(self, change): self._b64value = base64.b64encode(change['new'])
lancezlin/ml_template_py
lib/python2.7/site-packages/ipywidgets/widgets/widget_image.py
Python
mit
1,267
0
# coding=utf-8 import unittest """826. Most Profit Assigning Work https://leetcode.com/problems/most-profit-assigning-work/description/ We have jobs: `difficulty[i]` is the difficulty of the `i`th job, and `profit[i]` is the profit of the `i`th job. Now we have some workers. `worker[i]` is the ability of the `i`th worker, which means that this worker can only complete a job with difficulty at most `worker[i]`. Every worker can be assigned at most one job, but one job can be completed multiple times. For example, if 3 people attempt the same job that pays $1, then the total profit will be $3. If a worker cannot complete any job, his profit is $0. What is the most profit we can make? **Example 1:** **Input:** difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7] **Output:** 100 **Explanation: W** orkers are assigned jobs of difficulty [4,4,6,6] and they get profit of [20,20,30,30] seperately. **Notes:** * `1 <= difficulty.length = profit.length <= 10000` * `1 <= worker.length <= 10000` * `difficulty[i], profit[i], worker[i]` are in range `[1, 10^5]` Similar Questions: """ class Solution(object): def maxProfitAssignment(self, difficulty, profit, worker): """ :type difficulty: List[int] :type profit: List[int] :type worker: List[int] :rtype: int """ def test(self): pass if __name__ == "__main__": unittest.main()
openqt/algorithms
leetcode/python/lc826-most-profit-assigning-work.py
Python
gpl-3.0
1,478
0.004736
#!/usr/bin/python # -*- coding: utf-8 -*- import random import os def getRandomTime(sleepTime): def wrapper(): return sleepTime * random.random() return wrapper class MisUtils(object): """ 管理配置的类 """ refreshSleep = getRandomTime(10) # 刷新的间隔时间 wechatPushSleep = getRandomTime(1) # 发送两条微信消息之间的间隔 maxAttempt = 100 # wechatGroup_ = ['研究生的咸♂鱼生活'] # 讲座推送的微信群名称 # wechatUser_ = ['邱大帅全宇宙粉丝后援会'] # 讲座推送的用户名称 attempt = maxAttempt logPath = 'robber.log' confFile = 'robber.conf' blackList = 'blackList' sender = 'class_robber@cycoe.win' emailPassword = 'class_robber' host = 'smtp.ym.163.com' wechatURI = 'wxp://f2f0PYx27X0CWU1yiBhSKeHHgYzfA27iOicM' alipayURI = 'HTTPS://QR.ALIPAY.COM/FKX01669SBV7NA4ALTVPE8' confDict = { 'userName': '', 'password': '', 'receiver': '', } @staticmethod def checkConfFile(): return os.path.exists(MisUtils.confFile) @staticmethod def loadConfFile(): with open(MisUtils.confFile) as fr: content_ = fr.readlines() for content in content_: pair_ = content.split(':') pair_ = [pair.strip() for pair in pair_] if len(pair_) == 2: MisUtils.confDict[pair_[0]] = pair_[1] elif len(pair_) == 1: MisUtils.confDict[pair_[0]] = '' @staticmethod def dumpConfFile(): with open(MisUtils.confFile, 'w') as fr: for key in MisUtils.confDict.keys(): fr.write(str(key)) fr.write(': ') fr.write(str(MisUtils.confDict[key])) fr.write('\n') @staticmethod def setEmailInfo(): if MisUtils.checkConfFile(): MisUtils.loadConfFile() MisUtils.confDict['receiver'] = input('> receiver email: ') @staticmethod def initAttempt(): MisUtils.attempt = MisUtils.maxAttempt @staticmethod def descAttempt(): MisUtils.attempt -= 1 if MisUtils.attempt > 0: return True else: # if Mail.connectedToMail: # threading.Thread(target=Mail.send_mail, args=('Class robber halted', Logger.log( # 'Class robber halted because of up to max attempts', # ['Check your login status', 'Check the response of server'] # ),)).start() return False @staticmethod def getSelected(): if os.path.exists(MisUtils.blackList): with open(MisUtils.blackList) as fr: return [selected.strip() for selected in fr.readlines()] else: return [] @staticmethod def mergeSelected(newSelected_): if os.path.exists(MisUtils.blackList): with open(MisUtils.blackList) as fr: oriSelected_ = [selected.strip() for selected in fr.readlines()] else: oriSelected_ = [] oriSelected_.extend(newSelected_) oriSelected_ = set(oriSelected_) with open(MisUtils.blackList, 'w') as fr: for oriSelected in oriSelected_: fr.write(oriSelected + '\n')
cycoe/class_robber
modules/MisUtils.py
Python
mit
3,375
0.000924
from bamboo_boy.materials import Clump import random import factory from comments.models import DocumentComment, DocumentNode, NodeSnapshot from rtd_tests.factories.general_factories import UserFactory from rtd_tests.factories.projects_factories import ProjectFactory class SnapshotFactory(factory.DjangoModelFactory): FACTORY_FOR = NodeSnapshot hash = random.getrandbits(128) node = factory.SubFactory( 'rtd_tests.test.comments_factories.DocumentNodeFactory') class DocumentNodeFactory(factory.DjangoModelFactory): FACTORY_FOR = DocumentNode project = factory.SubFactory(ProjectFactory) version = factory.LazyAttribute(lambda a: a.project.versions.all()[0]) page = "page-about-nothing" @classmethod def _create(self, *args, **kwargs): if not kwargs.get('hash'): kwargs['hash'] = random.getrandbits(128) if not kwargs.get('commit'): kwargs['commit'] = random.getrandbits(128) return super(DocumentNodeFactory, self)._create(*args, **kwargs) class DocumentCommentFactory(factory.DjangoModelFactory): FACTORY_FOR = DocumentComment user = factory.SubFactory(UserFactory) text = "This is a comment." node = factory.SubFactory(DocumentNodeFactory) class ProjectsWithComments(Clump): def build_canopy(self): self.moderated_project = self.include_factory(ProjectFactory, 1, comment_moderation=True )[0] self.moderated_node = self.include_factory( DocumentNodeFactory, 1, project=self.moderated_project)[0] self.first_moderated_comment, self.second_moderated_comment = self.include_factory( DocumentCommentFactory, 2, node=self.moderated_node) self.unmoderated_project = self.include_factory(ProjectFactory, 1, comment_moderation=False )[0] self.unmoderated_node = self.include_factory( DocumentNodeFactory, 1, project=self.unmoderated_project)[0] self.first_unmoderated_comment, self.second_unmoderated_comment = self.include_factory( DocumentCommentFactory, 2, node=self.unmoderated_node) self.owner = self.include_factory( UserFactory, 1, username="owner", password="test")[0] self.moderated_project.users.add(self.owner) self.unmoderated_project.users.add(self.owner)
takluyver/readthedocs.org
readthedocs/rtd_tests/factories/comments_factories.py
Python
mit
2,656
0.00113
#!/usr/bin/env python from random import randint, choice from copy import deepcopy from math import log import sys import cProfile def fuse(m, x, adj_list): #print 'Fusing ({}) and ({})'.format(self.x, x.x) #for i in self.edges: # print '({})'.format(i.x), #print '' new_edge_list = [] for i in adj_list[m]: if not x == i: new_edge_list.append(i) for x_neigh in adj_list[x]: if not m == x_neigh: new_edge_list.append(x_neigh) for i in range(len(adj_list[x_neigh])): if adj_list[x_neigh][i] == x: adj_list[x_neigh][i] = m adj_list[m] = new_edge_list #for i in m.edges: # print '({})'.format(i.x), #print '' #print 'Done' ''' def __str__(self): str_tmp = [] for i in self.edges: str_tmp.append('({})'.format(i.x)) fused_tmp = [] for i in self.fused_nodes: fused_tmp.append('({})'.format(i.x)) return '[ ({}) : {str_tmp} : Fused Nodes: {fused_tmp} ]'.format(self.x, str_tmp = str_tmp, fused_tmp = fused_tmp) ''' def print_adj_list(adj_list): for node in adj_list: print adj_list[node] def random_contraction(adj_list): if len(adj_list) <= 2: return pivot = choice(adj_list.keys()) x = choice(adj_list[pivot]) #print '--------' #print 'Contracting {} and {}'.format(adj_list[pivot], adj_list[x.x]) fuse(pivot, x, adj_list) del adj_list[x] #print 'After Contraction' #print_adj_list(adj_list) #print '--------' if len(adj_list) > 2: random_contraction(adj_list) def main_1(): adj_list = {} fd = open(sys.argv[1]) for line in fd.readlines(): line = line.strip('\n') line = line.strip() arr = [ int(x.strip()) for x in line.split('\t') ] a = arr.pop(0) if a not in adj_list: adj_list[a] = [] for i in arr: if i not in adj_list: adj_list[i] = [] adj_list[a].append(i) original = adj_list #print_adj_list(adj_list) n = len(adj_list) #number_of_trials = int((n ** 2) * log(n)) + 1 number_of_trials = int((n ** 2)) number_of_trials = 5 # FIXME print 'Total number of tries: {}'.format(number_of_trials) minimum_cuts = False for i in range(number_of_trials): adj_list = deepcopy(original) #print_adj_list(adj_list) random_contraction(adj_list) #print_adj_list(adj_list) for k in adj_list: cuts = len(adj_list[k]) if not minimum_cuts or cuts < minimum_cuts: minimum_cuts = cuts print 'Cuts in {}th run is {}. Min cuts {}'.format(i + 1, cuts, minimum_cuts) print 'Minimum cut : {}'.format(minimum_cuts) return None if __name__ == '__main__': #profile.run('main_1()') cProfile.runctx('main_1()', None, locals()) #main_1()
Ramyak/CodingPractice
algo_practice/coursera-algo-1/min_cuts/minimum_cuts_1_pre.py
Python
gpl-2.0
2,942
0.008838
## # Copyright 2009-2015 Ghent University # # This file is part of EasyBuild, # originally created by the HPC team of Ghent University (http://ugent.be/hpc/en), # with support of Ghent University (http://ugent.be/hpc), # the Flemish Supercomputer Centre (VSC) (https://vscentrum.be/nl/en), # the Hercules foundation (http://www.herculesstichting.be/in_English) # and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en). # # http://github.com/hpcugent/easybuild # # EasyBuild is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation v2. # # EasyBuild is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with EasyBuild. If not, see <http://www.gnu.org/licenses/>. ## """ EasyBuild support for installing the Intel Advisor XE, implemented as an easyblock @author: Lumir Jasiok (IT4Innovations) """ from easybuild.easyblocks.generic.intelbase import IntelBase class EB_Advisor(IntelBase): """ Support for installing Intel Advisor XE """ def sanity_check_step(self): """Custom sanity check paths for Advisor""" custom_paths = { 'files': [], 'dirs': ['advisor_xe/bin64', 'advisor_xe/lib64'] } super(EB_Advisor, self).sanity_check_step(custom_paths=custom_paths) def make_module_req_guess(self): """ A dictionary of possible directories to look for """ guesses = super(EB_Advisor, self).make_module_req_guess() lib_path = 'advisor_xe/lib64' include_path = 'advisor_xe/include' guesses.update({ 'CPATH': [include_path], 'INCLUDE': [include_path], 'LD_LIBRARY_PATH': [lib_path], 'LIBRARY_PATH': [lib_path], 'PATH': ['advisor_xe/bin64'], }) return guesses
valtandor/easybuild-easyblocks
easybuild/easyblocks/a/advisor.py
Python
gpl-2.0
2,158
0.002317
#!/usr/bin/env python import sys import numpy as np import matplotlib.pyplot as plt from scipy.special import gammaincinv import pint.models, pint.toa import astropy.units as u from pint.residuals import Residuals import traceback #np.seterr(all='raise') def sigmaz(t,y,err,nseg,diagplot=False): """Compute sigma_z from lists of measurement times and values. Input: ------ t: array of floats The measurement times (days). y: array of floats The measurement values (seconds). err: array of floats (1D) Error bars of the measurements (seconds). nseg : array of ints In each iteration, the total time span of the measurements will be split into Nseg segments. This array contains all the values of Nseg we want to use. diagplot: bool Make a diagnostic plot of the polynomial fit to the full set of measurements. Output: ------- sz_corr : array of floats Values of bias-corrected sigma-z for different segment length tau. szerr_lower : array of floats Lower error bars for the sigma-z values. szerr_upper : array of floats Upper error bars for the sigma-z values. tz : array of floats The values of the segment lengths, tau (days), for which sigma-z was calculated. nsegments : array of ints How many segments of each recorded length passed all criteria for being used when calculating tau and sigma-z statistics. """ # The length of the output arrays depends on how many segments meet our criteria of more than 6 points, and longer than T/sqrt(2) sz = [] tz = [] ngood = [] # How many good segments went into each tz,sz point toas = t toaerr = err toares = y # Total span of the TOAs durationday = (toas[-1]-toas[0]) # days durationsec = durationday*86400.0 # seconds #The amount of wiggle room for the TOAs to fall on the other side of the segment range and still be included. It's really only supposed to account for roundoff error. We have no reason to expect TOAs to fall on the border except for the first and last TOAs of the whole batch, so I don't believe we're in danger of double counting any TOAs. wiggle = 1e-5 # Polynomial order to fit (a cubic may fail to produce a good fit for a long TOA span for pulsars with a lot of red noise; it fails for the NANOGrav data set on B1937+21). polyorder = 3 for iseg in nseg: # For each duration of length durationday/iseg compute sz. dur_oneseg = durationday/iseg # how long is one segment ngoodsegs = 0 # Reset the counter for good segments C3sqr = 0 # This will accumulate values of C3sqr C3un_sum = 0 # This will accumulate the sum of 1/C3_sigma^2 to normalize the C3^2 weights at the end n_sing_matrix = 0 # how many segments make polyfit fail with a singular matrix error n_few_points = 0 # how many segments have too few points n_short_dataspan = 0 # in how many segments the points are clustered within too small a portion of the selected time span n_C3_neg_var = 0 # for how many segments the C3 coefficient has a negative variance in the covariance matrix for jseg in range (0, iseg): # Now loop through each segment of this length # for iseq > 1 there are multiple segments we need to analyze segrange=(toas[0]+dur_oneseg*jseg, toas[0]+dur_oneseg*(jseg+1)) centertime = (segrange[1]+segrange[0])/2.0 # Midpoint of observation interval # Fit the polynomial using only the toas in the interval desind = np.where((toas>(segrange[0]-wiggle)) & (toas<(segrange[1]+wiggle))) if (np.size(desind))>polyorder+3: # if cov. matrix needed for error estimates on fitted params #if (np.size(desind))>polyorder: # if cov. matrix not needed dataspan = np.max(toas[desind]) - np.min(toas[desind]) else: n_few_points = n_few_points+1 continue # Matsakis recommends segment be longer than dur_oneseg/sqrt(2) if (dataspan<=(dur_oneseg/np.sqrt(2))): #xAL added this criterion n_short_dataspan = n_short_dataspan+1 continue else: res = toares[desind] toaerrs = toaerr[desind] try: #NOTE: polyfit needs 1/sigma, not 1/sigma^2 weights. Times and residuals need to be in the same units, here are in seconds p,pcov = np.polyfit((toas[desind]-centertime)*86400.0, res.astype(np.float), polyorder, cov=True, full=False, w=np.abs(1./toaerrs) ) #p = np.polyfit((toas[desind]-centertime)*86400.0, # res.astype(np.float),polyorder, cov=False, full=False, w = np.abs(1./toaerrs) ) except: #print('Polyfit failed!') #traceback.print_exc() n_sing_matrix = n_sing_matrix+1 continue # Get C3 coefficient uncertainty from the covariance matrix C3variance = np.diag(pcov)[-4] if C3variance < 0: n_C3_neg_var = n_C3_neg_var+1 #print('C3variance = %e' % C3variance) continue C3un = np.sqrt(C3variance) C3un_sum = C3un_sum + 1.0/C3un**2 # for normalizing weights at the end C3sqr=C3sqr + p[-4]**2/C3un**2 #C3sqr=C3sqr+p[0]**2 # Accumulate to eventually find avg C3^2 ngoodsegs += 1 # the number of good segments (with at least 6 TOAs in them) # Plot data and fit for case where the full set of resids is treated as one segment if (iseg==1 and diagplot): fig = plt.figure() ax = fig.add_subplot(1, 1, 1) toas_secs = (toas[desind]-centertime)*86400.0 ax.plot(toas[desind], res.astype(np.float)*1.e6, 'ko') ax.errorbar(toas[desind],res.astype(np.float)*1.e6,yerr=toaerr[desind]*1.e6,fmt='none',color='k',capsize=2.0) ax.plot(toas[desind], np.polyval(p,toas_secs)*1.e6,'r') ax.set_xlabel('MJD') ax.set_ylabel('Res (us)') plt.title('Order-%d polynomial fit to full TOA set' % polyorder) #plt.savefig("sigmaz-diagnostic.png", dpi=300, format='png', bbox_inches='tight') print("Divided data into %d segments of length %.1f days. Number of good segments: %d" % (iseg, dur_oneseg, ngoodsegs)) if n_few_points > 0: print('--->Segments with too few TOAs: %d' % n_few_points) if n_short_dataspan > 0: print('--->Segments with too short TOA span: %d' % n_short_dataspan) if n_sing_matrix > 0: print('--->Segments causing singular matrix error in polyfit: %d' % n_sing_matrix) if n_C3_neg_var > 0: print('--->Segments with C3 variance <0: %d' % n_C3_neg_var) if ngoodsegs != 0: #C3sqr=C3sqr/ngoodsegs # unweighted average C3sqr=C3sqr/C3un_sum # average weighted by the uncertainties in fitted C3 values sz.append((dur_oneseg*86400)**2*np.sqrt(C3sqr)/(2.0*np.sqrt(5.0))) # sigma_z formula tz.append(dur_oneseg) #days ngood.append(ngoodsegs) # Sigma-z bias correction and error bars nsegments = np.array(ngood) x16 = np.divide(gammaincinv(0.5*nsegments, 0.16), 0.5*nsegments) x50 = np.divide(gammaincinv(0.5*nsegments, 0.50), 0.5*nsegments) x84 = np.divide(gammaincinv(0.5*nsegments, 0.84), 0.5*nsegments) sz_corr = np.divide(sz,np.sqrt(x50)) szerr_upper = np.multiply(sz_corr, np.sqrt(np.divide(x50,x16))-1.0) szerr_lower = np.multiply(sz_corr, 1.0-np.sqrt(np.divide(x50,x84))) return sz_corr, szerr_lower, szerr_upper, tz, nsegments def psr_sigmaz(parfile,timfile,nseg,diagplot=False): """Compute sigma-z from a pulsar par and tim file. Input: ------ timfile : string The file containing TOAs, in Tempo/Tempo2 format. parfile : string The file containing the timing model. nseg : array of ints In each iteration, the total time span of the TOAs will be split into Nseg segments. This array contains all the values of Nseg we want to use. diagplot: bool Make a diagnostic plot of the polynomial fit to the full set of TOAs. Output: ------- sz_corr : array of floats Values of bias-corrected sigma-z for different segment length tau. szerr_lower : array of floats Lower error bars for the sigma-z values. szerr_upper : array of floats Upper error bars for the sigma-z values. tz : array of floats The values of the segment lengths, tau (days), for which sigma-z was calculated. nsegments : array of ints How many segments of each recorded length passed all criteria for being used when calculating tau and sigma-z statistics. """ # Read in the TOAs and timing model and compute the residuals m = pint.models.get_model(parfile) t = pint.toa.get_TOAs(timfile,ephem='DE430') t.compute_pulse_numbers(m) toas = t.get_mjds().value #MJD toaerr = t.get_errors().to(u.s).value #s toares = Residuals(t,m).time_resids.to(u.s).value #s return sigmaz(toas,toares,toaerr,nseg,diagplot) if __name__ == "__main__": if len(sys.argv) != 3: print('Usage: sigmaz.py [parfile] [timfile]') sys.exit() par = sys.argv[1] tim = sys.argv[2] seggrid = np.logspace(0.1,3,num=50) seggrid = seggrid.astype(int) seggrid = np.unique(seggrid) #seggrid = 2**np.arange(0,10) sz,errlo,errhi,tz,ns = psr_sigmaz(par,tim,seggrid,diagplot=True) fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.plot(tz, sz, 'ko',label="Sigma-z") ax.errorbar(tz,sz,yerr=[errlo,errhi],fmt='none',color='k',capsize=2.0) ax.grid(which='both') ax.set_xscale('log') ax.set_yscale('log') ax.set_xlabel('Time (days)') ax.set_ylabel('Sigma-z') plt.title('%s\n%s' % (par,tim)) plt.show()
paulray/NICERsoft
nicer/sigmaz.py
Python
mit
10,393
0.014529
# coding=utf8 """ Parser for todo format string. from todo.parser import parser parser.parse(string) # return an Todo instance """ from models import Task from models import Todo from ply import lex from ply import yacc class TodoLexer(object): """ Lexer for Todo format string. Tokens ID e.g. '1.' DONE e.g. '(x)' TASK e.g. 'This is a task' """ tokens = ( "ID", "DONE", "TASK", ) t_ignore = "\x20\x09" # ignore spaces and tabs def t_ID(self, t): r'\d+\.([uU]|[lL]|[uU][lL]|[lL][uU])?' t.value = int(t.value[:-1]) return t def t_DONE(self, t): r'(\(x\))' return t def t_TASK(self, t): r'((?!\(x\))).+' return t def t_newline(self, t): r'\n+' t.lexer.lineno += len(t.value) def t_error(self, t): raise SyntaxError( "Illegal character: '%s' at Line %d" % (t.value[0], t.lineno) ) def __init__(self): self.lexer = lex.lex(module=self) class TodoParser(object): """ Parser for Todo format string, works with a todo lexer. Parse string to Python list todo_str = "1. (x) Write email to tom" TodoParser().parse(todo_str) """ tokens = TodoLexer.tokens def p_error(self, p): if p: raise SyntaxError( "Character '%s' at line %d" % (p.value[0], p.lineno) ) else: raise SyntaxError("SyntaxError at EOF") def p_start(self, p): "start : translation_unit" p[0] = self.todo def p_translation_unit(self, p): """ translation_unit : translate_task | translation_unit translate_task | """ pass def p_translation_task(self, p): """ translate_task : ID DONE TASK | ID TASK """ if len(p) == 4: done = True content = p[3] elif len(p) == 3: done = False content = p[2] task = Task(p[1], content, done) self.todo.append(task) def __init__(self): self.parser = yacc.yacc(module=self, debug=0, write_tables=0) def parse(self, data): # reset list self.todo = Todo() return self.parser.parse(data) lexer = TodoLexer() # build lexer parser = TodoParser() # build parser
guori12321/todo
todo/parser.py
Python
mit
2,473
0
"""Package entry point.""" import importlib import os import sys from gitman.cli import main # Declare itself as package if needed for better debugging support # pylint: disable=multiple-imports,wrong-import-position,redefined-builtin,used-before-assignment if __name__ == '__main__' and __package__ is None: # pragma: no cover parent_dir = os.path.abspath(os.path.dirname(__file__)) sys.path.append(os.path.dirname(parent_dir)) __package__ = os.path.basename(parent_dir) importlib.import_module(__package__) if __name__ == '__main__': # pragma: no cover main()
jacebrowning/gdm
gitman/__main__.py
Python
mit
590
0.001695
# Copyright 2012-2013 Red Hat, Inc. # # 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. """ A helper class for proxy objects to remote APIs. For more information about rpc API version numbers, see: rpc/dispatcher.py """ import six from ceilometer.openstack.common import rpc from ceilometer.openstack.common.rpc import common as rpc_common from ceilometer.openstack.common.rpc import serializer as rpc_serializer class RpcProxy(object): """A helper class for rpc clients. This class is a wrapper around the RPC client API. It allows you to specify the topic and API version in a single place. This is intended to be used as a base class for a class that implements the client side of an rpc API. """ # The default namespace, which can be overridden in a subclass. RPC_API_NAMESPACE = None def __init__(self, topic, default_version, version_cap=None, serializer=None): """Initialize an RpcProxy. :param topic: The topic to use for all messages. :param default_version: The default API version to request in all outgoing messages. This can be overridden on a per-message basis. :param version_cap: Optionally cap the maximum version used for sent messages. :param serializer: Optionaly (de-)serialize entities with a provided helper. """ self.topic = topic self.default_version = default_version self.version_cap = version_cap if serializer is None: serializer = rpc_serializer.NoOpSerializer() self.serializer = serializer super(RpcProxy, self).__init__() def _set_version(self, msg, vers): """Helper method to set the version in a message. :param msg: The message having a version added to it. :param vers: The version number to add to the message. """ v = vers if vers else self.default_version if (self.version_cap and not rpc_common.version_is_compatible(self.version_cap, v)): raise rpc_common.RpcVersionCapError(version_cap=self.version_cap) msg['version'] = v def _get_topic(self, topic): """Return the topic to use for a message.""" return topic if topic else self.topic def can_send_version(self, version): """Check to see if a version is compatible with the version cap.""" return (not self.version_cap or rpc_common.version_is_compatible(self.version_cap, version)) @staticmethod def make_namespaced_msg(method, namespace, **kwargs): return {'method': method, 'namespace': namespace, 'args': kwargs} def make_msg(self, method, **kwargs): return self.make_namespaced_msg(method, self.RPC_API_NAMESPACE, **kwargs) def _serialize_msg_args(self, context, kwargs): """Helper method called to serialize message arguments. This calls our serializer on each argument, returning a new set of args that have been serialized. :param context: The request context :param kwargs: The arguments to serialize :returns: A new set of serialized arguments """ new_kwargs = dict() for argname, arg in six.iteritems(kwargs): new_kwargs[argname] = self.serializer.serialize_entity(context, arg) return new_kwargs def call(self, context, msg, topic=None, version=None, timeout=None): """rpc.call() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :param timeout: (Optional) A timeout to use when waiting for the response. If no timeout is specified, a default timeout will be used that is usually sufficient. :returns: The return value from the remote method. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) real_topic = self._get_topic(topic) try: result = rpc.call(context, real_topic, msg, timeout) return self.serializer.deserialize_entity(context, result) except rpc.common.Timeout as exc: raise rpc.common.Timeout( exc.info, real_topic, msg.get('method')) def multicall(self, context, msg, topic=None, version=None, timeout=None): """rpc.multicall() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :param timeout: (Optional) A timeout to use when waiting for the response. If no timeout is specified, a default timeout will be used that is usually sufficient. :returns: An iterator that lets you process each of the returned values from the remote method as they arrive. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) real_topic = self._get_topic(topic) try: result = rpc.multicall(context, real_topic, msg, timeout) return self.serializer.deserialize_entity(context, result) except rpc.common.Timeout as exc: raise rpc.common.Timeout( exc.info, real_topic, msg.get('method')) def cast(self, context, msg, topic=None, version=None): """rpc.cast() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.cast() does not wait on any return value from the remote method. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.cast(context, self._get_topic(topic), msg) def fanout_cast(self, context, msg, topic=None, version=None): """rpc.fanout_cast() a remote method. :param context: The request context :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.fanout_cast() does not wait on any return value from the remote method. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.fanout_cast(context, self._get_topic(topic), msg) def cast_to_server(self, context, server_params, msg, topic=None, version=None): """rpc.cast_to_server() a remote method. :param context: The request context :param server_params: Server parameters. See rpc.cast_to_server() for details. :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.cast_to_server() does not wait on any return values. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.cast_to_server(context, server_params, self._get_topic(topic), msg) def fanout_cast_to_server(self, context, server_params, msg, topic=None, version=None): """rpc.fanout_cast_to_server() a remote method. :param context: The request context :param server_params: Server parameters. See rpc.cast_to_server() for details. :param msg: The message to send, including the method and args. :param topic: Override the topic for this message. :param version: (Optional) Override the requested API version in this message. :returns: None. rpc.fanout_cast_to_server() does not wait on any return values. """ self._set_version(msg, version) msg['args'] = self._serialize_msg_args(context, msg['args']) rpc.fanout_cast_to_server(context, server_params, self._get_topic(topic), msg)
NeCTAR-RC/ceilometer
ceilometer/openstack/common/rpc/proxy.py
Python
apache-2.0
9,459
0
# -*- coding: utf-8 -*- """ rdd.exceptions ~~~~~~~~~~~~~~ This module contains the exceptions raised by rdd. """ from requests.exceptions import * class ReadabilityException(RuntimeError): """Base class for Readability exceptions.""" class ShortenerError(ReadabilityException): """Failed to shorten URL.""" class MetadataError(ReadabilityException): """Failed to retrieve metadata."""
mlafeldt/rdd.py
rdd/exceptions.py
Python
mit
407
0