input
stringlengths
0
2.17k
instruction
stringlengths
18
2.94k
output
stringlengths
47
3.36k
# -*- encoding: utf-8 -*- ############################################################################## # # Copyright (C) 2015 Compassion CH (http://www.compassion.ch) # Releasing children from poverty in Jesus' name # @author: Emanuel Cino <[email protected]> # # The licence is in the file __openerp__.py # ############################################################################## from . import xmlrpc_helper
Fix comment header on init
# -*- encoding: utf-8 -*- ############################################################################## # # Copyright (C) 2015 Compassion CH (http://www.compassion.ch) # Releasing children from poverty in Jesus' name # @author: Emmanuel Mathier <[email protected]> # # The licence is in the file __openerp__.py # ############################################################################## from . import xmlrpc_helper
from species import CODES def all_region_codes(): return CODES.keys def all_species_codes(): return species_codes_for_regions(all_region_codes) def species_codes_for_regions(region_codes): if region_codes is None: return None species_codes = [] for region_code in region_codes: species_codes.extend(CODES[region_code]) # Converting to a set removes duplicates return list(set(species_codes))
Fix typo that prevented instance creation
from species import CODES def all_region_codes(): return CODES.keys def all_species_codes(): return species_codes_for_regions(all_region_codes()) def species_codes_for_regions(region_codes): if region_codes is None: return None species_codes = [] for region_code in region_codes: species_codes.extend(CODES[region_code]) # Converting to a set removes duplicates return list(set(species_codes))
from functools import lru_cache import boto3 from pydantic import BaseSettings, Field, root_validator @lru_cache def get_secrets_client(): return boto3.client("secretsmanager") @lru_cache def get_secret(secret_id): client = get_secrets_client() secret_value = client.get_secret_value(SecretId=secret_id) return secret_value["SecretString"] class Config(BaseSettings): environment: str evm_full_node_url: str reward_root_submitter_address: str reward_root_submitter_private_key: str reward_root_submitter_sentry_dsn: str log_level: str = Field("WARNING") @root_validator(pre=True) def load_secrets(cls, values): env = values["environment"] for field_name, field in cls.__fields__.items(): # Check it isn't already set *and* there is no default if field_name not in values and field.default is None: values[field_name] = get_secret(f"{env}_{field_name}") return values class Config: env_file = ".env" env_file_encoding = "utf-8"
Set default logging to info
from functools import lru_cache import boto3 from pydantic import BaseSettings, Field, root_validator @lru_cache def get_secrets_client(): return boto3.client("secretsmanager") @lru_cache def get_secret(secret_id): client = get_secrets_client() secret_value = client.get_secret_value(SecretId=secret_id) return secret_value["SecretString"] class Config(BaseSettings): environment: str evm_full_node_url: str reward_root_submitter_address: str reward_root_submitter_private_key: str reward_root_submitter_sentry_dsn: str log_level: str = Field("INFO") @root_validator(pre=True) def load_secrets(cls, values): env = values["environment"] for field_name, field in cls.__fields__.items(): # Check it isn't already set *and* there is no default if field_name not in values and field.default is None: values[field_name] = get_secret(f"{env}_{field_name}") return values class Config: env_file = ".env" env_file_encoding = "utf-8"
import sys sys.path.insert(1, "../../../") import h2o def bigcatRF(ip,port): # Connect to h2o h2o.init(ip,port) # Training set has 100 categories from cat001 to cat100 # Categories cat001, cat003, ... are perfect predictors of y = 1 # Categories cat002, cat004, ... are perfect predictors of y = 0 #Log.info("Importing bigcat_5000x2.csv data...\n") bigcat = h2o.import_frame(path=h2o.locate("smalldata/gbm_test/bigcat_5000x2.csv")) bigcat["y"] = bigcat["y"].asfactor() #Log.info("Summary of bigcat_5000x2.csv from H2O:\n") #bigcat.summary() # Train H2O DRF Model: #Log.info("H2O DRF (Naive Split) with parameters:\nclassification = TRUE, ntree = 1, depth = 1, nbins = 100\n") model = h2o.random_forest(x=bigcat[["X"]], y=bigcat["y"], ntrees=1, max_depth=1, nbins=100) model.show() if __name__ == "__main__": h2o.run_test(sys.argv, bigcatRF)
Add usage of nbins_cats to RF pyunit.
import sys sys.path.insert(1, "../../../") import h2o def bigcatRF(ip,port): # Connect to h2o h2o.init(ip,port) # Training set has 100 categories from cat001 to cat100 # Categories cat001, cat003, ... are perfect predictors of y = 1 # Categories cat002, cat004, ... are perfect predictors of y = 0 #Log.info("Importing bigcat_5000x2.csv data...\n") bigcat = h2o.import_frame(path=h2o.locate("smalldata/gbm_test/bigcat_5000x2.csv")) bigcat["y"] = bigcat["y"].asfactor() #Log.info("Summary of bigcat_5000x2.csv from H2O:\n") #bigcat.summary() # Train H2O DRF Model: #Log.info("H2O DRF (Naive Split) with parameters:\nclassification = TRUE, ntree = 1, depth = 1, nbins = 100, nbins_cats=10\n") model = h2o.random_forest(x=bigcat[["X"]], y=bigcat["y"], ntrees=1, max_depth=1, nbins=100, nbins_cats=10) model.show() if __name__ == "__main__": h2o.run_test(sys.argv, bigcatRF)
"""Test GitHub issue #4. Diagram could not be loaded due to JuggleError (presumed cyclic resolving of diagram items). """ from gi.repository import GLib, Gtk from gaphor.storage.storage import load class TestCyclicDiagram: def test_bug(self, case, test_models): """Load file. This does not nearly resemble the error, since the model should be loaded from within the mainloop (which will delay all updates). """ path = test_models / "dbus.gaphor" load(path, case.element_factory, case.modeling_language) def test_bug_idle(self, case, test_models): """Load file in gtk main loop. This does not nearly resemble the error, since the model should be loaded from within the mainloop (which will delay all updates). """ def handler(): try: path = test_models / "dbus.gaphor" load(path, case.element_factory, case.modeling_language) finally: Gtk.main_quit() assert GLib.timeout_add(1, handler) > 0 Gtk.main()
Convert load_model tests to pytest functions
# flake8: noqa F401,F811 """Diagram could not be loaded due to JuggleError (presumed cyclic resolving of diagram items).""" from gi.repository import GLib, Gtk from gaphor.diagram.tests.fixtures import ( element_factory, event_manager, modeling_language, ) from gaphor.storage.storage import load def test_cyclic_diagram_bug(element_factory, modeling_language, test_models): """Load file. This does not nearly resemble the error, since the model should be loaded from within the mainloop (which will delay all updates). """ path = test_models / "dbus.gaphor" load(path, element_factory, modeling_language) def test_cyclic_diagram_bug_idle(element_factory, modeling_language, test_models): """Load file in gtk main loop. This does not nearly resemble the error, since the model should be loaded from within the mainloop (which will delay all updates). """ def handler(): try: path = test_models / "dbus.gaphor" load(path, element_factory, modeling_language) finally: Gtk.main_quit() assert GLib.timeout_add(1, handler) > 0 Gtk.main()
from __future__ import print_function import json from argh import ArghParser, arg from ghtools import cli from ghtools.api import GithubAPIClient parser = ArghParser(description="Browse the GitHub API") @arg('github', nargs='?', help='GitHub instance nickname (e.g "enterprise")') @arg('url', help='URL to browse') @arg('-m', '--method', default='get', choices=('get', 'delete'), help='HTTP method to use.') def browse(args): """ Print the GitHub API response at the given URL """ with cli.catch_api_errors(): client = GithubAPIClient(nickname=args.github) res = client.request(args.method, args.url, _raise=False) print('HTTP/1.1 {0} {1}'.format(res.status_code, res.reason)) for k, v in res.headers.items(): print("{0}: {1}".format(k, v)) print() if res.json() is not None: print(json.dumps(res.json, indent=2)) else: print(res.content) parser.set_default_command(browse) def main(): parser.dispatch() if __name__ == '__main__': main()
Add missed json to json() tweak
from __future__ import print_function import json from argh import ArghParser, arg from ghtools import cli from ghtools.api import GithubAPIClient parser = ArghParser(description="Browse the GitHub API") @arg('github', nargs='?', help='GitHub instance nickname (e.g "enterprise")') @arg('url', help='URL to browse') @arg('-m', '--method', default='get', choices=('get', 'delete'), help='HTTP method to use.') def browse(args): """ Print the GitHub API response at the given URL """ with cli.catch_api_errors(): client = GithubAPIClient(nickname=args.github) res = client.request(args.method, args.url, _raise=False) print('HTTP/1.1 {0} {1}'.format(res.status_code, res.reason)) for k, v in res.headers.items(): print("{0}: {1}".format(k, v)) print() if res.json() is not None: print(json.dumps(res.json(), indent=2)) else: print(res.content) parser.set_default_command(browse) def main(): parser.dispatch() if __name__ == '__main__': main()
import sys def lowest_unique(int_list): numbers = {} for index in range(len(int_list)): group = numbers.setdefault(int(int_list[index]), []) group.append(index) for number in numbers: retval = numbers[number] if len(retval) == 1: return retval[0] + 1 return 0 if __name__ == '__main__': inputfile = sys.argv[1] with open(inputfile, 'r') as f: for line in f: line_list = line.rstrip().split() if line_list: print str(lowest_unique(line_list))
Improve solution by using enumerate
import sys def lowest_unique(int_list): numbers = {} for index, number in enumerate(int_list): group = numbers.setdefault(int(number), []) group.append(index) for number in sorted(numbers.keys()): retval = numbers[number] if len(retval) == 1: return retval[0] + 1 return 0 if __name__ == '__main__': inputfile = sys.argv[1] with open(inputfile, 'r') as f: for line in f: line_list = line.rstrip().split() if line_list: print str(lowest_unique(line_list))
from distutils.core import setup setup( name='python3-indy', version='1.6.1', packages=['indy'], url='https://github.com/hyperledger/indy-sdk', license='MIT/Apache-2.0', author='Vyacheslav Gudkov', author_email='[email protected]', description='This is the official SDK for Hyperledger Indy (https://www.hyperledger.org/projects), which provides a distributed-ledger-based foundation for self-sovereign identity (https://sovrin.org). The major artifact of the SDK is a c-callable library.', install_requires=['pytest', 'pytest-asyncio', 'base58'], tests_require=['pytest', 'pytest-asyncio', 'base58'] )
Fix pytest version in python wrapper deps. Signed-off-by: Sergey Minaev <[email protected]>
from distutils.core import setup setup( name='python3-indy', version='1.6.1', packages=['indy'], url='https://github.com/hyperledger/indy-sdk', license='MIT/Apache-2.0', author='Vyacheslav Gudkov', author_email='[email protected]', description='This is the official SDK for Hyperledger Indy (https://www.hyperledger.org/projects), which provides a distributed-ledger-based foundation for self-sovereign identity (https://sovrin.org). The major artifact of the SDK is a c-callable library.', install_requires=['pytest<3.7', 'pytest-asyncio', 'base58'], tests_require=['pytest<3.7', 'pytest-asyncio', 'base58'] )
import RDF import zope.interface import interfaces import rdf_helper class Jurisdiction(object): zope.interface.implements(interfaces.IJurisdiction) def __init__(self, short_name): '''@param short_name can be e.g. mx''' model = rdf_helper.init_model( rdf_helper.JURI_RDF_PATH) self.code = short_name self.id = 'http://creativecommons.org/international/%s/' % short_name id_uri = RDF.Uri(self.id) self.local_url = rdf_helper.query_to_single_value(model, id_uri, RDF.Uri(rdf_helper.NS_CC + 'jurisdictionSite'), None) self.launched = rdf_helper.query_to_single_value(model, id_uri, RDF.Uri(rdf_helper.NS_CC + 'launched'), None)
Add documentation and make Jurisdiction calls not fail when some of the values aren't found.
import RDF import zope.interface import interfaces import rdf_helper class Jurisdiction(object): zope.interface.implements(interfaces.IJurisdiction) def __init__(self, short_name): """Creates an object representing a jurisdiction. short_name is a (usually) two-letter code representing the same jurisdiction; for a complete list, see cc.license.jurisdiction_codes()""" model = rdf_helper.init_model( rdf_helper.JURI_RDF_PATH) self.code = short_name self.id = 'http://creativecommons.org/international/%s/' % short_name id_uri = RDF.Uri(self.id) try: self.local_url = rdf_helper.query_to_single_value(model, id_uri, RDF.Uri(rdf_helper.NS_CC + 'jurisdictionSite'), None) except rdf_helper.NoValuesFoundException: self.local_url = None try: self.launched = rdf_helper.query_to_single_value(model, id_uri, RDF.Uri(rdf_helper.NS_CC + 'launched'), None) except rdf_helper.NoValuesFoundException: self.launched = None
# # Copyright (c) 2009 rPath, Inc. # # All Rights Reserved # from mint import amiperms class AWSHandler(object): def __init__(self, cfg, db): self.db = db self.amiPerms = amiperms.AMIPermissionsManager(cfg, db) def notify_UserProductRemoved(self, event, userId, projectId, userlevel = None): self.amiPerms.addMemberToProject(userId, projectId) def notify_UserProductAdded(self, event, userId, projectId, userlevel = None): self.amiPerms.deleteMemberFromProject(userId, projectId) def notify_UserProductChanged(self, event, userId, projectId, oldLevel, newLevel): self.amiPerms.setMemberLevel(userId, projectId, oldLevel, newLevel) def notify_UserCancelled(self, userId): # yuck. awsFound, oldAwsAccountNumber = self.db.userData.getDataValue( userId, 'awsAccountNumber') self.amiPerms.setUserKey(userId, oldAwsAccountNumber, None) def notify_ReleasePublished(self, releaseId): self.amiPerms.publishRelease(releaseId) def notify_ReleaseUnpublished(self, releaseId): self.amiPerms.unpublishRelease(releaseId)
Fix typo when setting up handler.
# # Copyright (c) 2009 rPath, Inc. # # All Rights Reserved # from mint import amiperms class AWSHandler(object): def __init__(self, cfg, db): self.db = db self.amiPerms = amiperms.AMIPermissionsManager(cfg, db) def notify_UserProductRemoved(self, event, userId, projectId, userlevel = None): self.amiPerms.deleteMemberFromProject(userId, projectId) def notify_UserProductAdded(self, event, userId, projectId, userlevel = None): self.amiPerms.addMemberToProject(userId, projectId) def notify_UserProductChanged(self, event, userId, projectId, oldLevel, newLevel): self.amiPerms.setMemberLevel(userId, projectId, oldLevel, newLevel) def notify_UserCancelled(self, userId): # yuck. awsFound, oldAwsAccountNumber = self.db.userData.getDataValue( userId, 'awsAccountNumber') self.amiPerms.setUserKey(userId, oldAwsAccountNumber, None) def notify_ReleasePublished(self, releaseId): self.amiPerms.publishRelease(releaseId) def notify_ReleaseUnpublished(self, releaseId): self.amiPerms.unpublishRelease(releaseId)
import sys import time import bracoujl.processor.gb_z80 as proc dis = proc.CPU_CONF['disassembler']() def disassemble(lines): res = '' for line in lines: op = proc.CPU_CONF['parse_line'](line) if op is None: continue res += '{:04X}'.format(op['pc']) + ' - ' + dis.disassemble(op) + '\n' res += '-' * 30 return res try: N = int(sys.argv[1]) except (ValueError, IndexError): N = -1 uniq, lines, count = set(), [], 0 for line in sys.stdin: if line == '--\n': tlines = disassemble(lines) if tlines not in uniq: uniq.add(tlines) print(tlines) lines = [] if N == count: sys.exit(0) count += 1 lines.append(line[:-1])
Fix and enhance disassemble miscellaneous script.
import argparse import sys import time import bracoujl.processor.gb_z80 as proc dis = proc.CPU_CONF['disassembler']() def disassemble(lines, keep_logs=False): res = [] for line in lines: op, gline = proc.CPU_CONF['parse_line'](line), '' if keep_logs: gline += line + (' | DIS: ' if op is not None else '') else: gline += '{:04X}'.format(op['pc']) + ' - ' if op is not None: gline += dis.disassemble(op) res.append(gline) res.append('-' * 20) return '\n'.join(res) uniq = set() def display_lines(lines, **kwds): tlines = disassemble(lines, **kwds) if tlines not in uniq: uniq.add(tlines) print(tlines) return [] if __name__ == '__main__': parser = argparse.ArgumentParser(description='Little disassembly helper.') parser.add_argument('-N', action='store', default=-1, help='number of uniq blocks displayed') parser.add_argument('-k', '--keep-logs', action='store_true', default=False, help='keep log lines') args = parser.parse_args(sys.argv[1:]) lines, count = [], 0 for line in sys.stdin: if line == '--\n': lines = display_lines(lines, keep_logs=args.keep_logs) if args.N == count: sys.exit(0) count += 1 lines.append(line[:-1]) if lines: display_lines(lines, keep_logs=args.keep_logs)
def configuration(parent_package='',top_path=None): from numpy.distutils.misc_util import Configuration config = Configuration('interfaces', parent_package, top_path) config.add_data_dir('tests') config.add_data_dir('script_templates') return config if __name__ == '__main__': from numpy.distutils.core import setup setup(**configuration(top_path='').todict())
Add fsl subpackage on install. git-svn-id: 24f545668198cdd163a527378499f2123e59bf9f@1050 ead46cd0-7350-4e37-8683-fc4c6f79bf00
def configuration(parent_package='',top_path=None): from numpy.distutils.misc_util import Configuration config = Configuration('interfaces', parent_package, top_path) config.add_subpackage('fsl') config.add_data_dir('tests') config.add_data_dir('script_templates') return config if __name__ == '__main__': from numpy.distutils.core import setup setup(**configuration(top_path='').todict())
#!/usr/bin/python from pytun import TunTapDevice from binascii import hexlify if __name__ == '__main__': tun = TunTapDevice(name='ipsec-tun') tun.up() tun.persist(True) while True: try: buf = tun.read(tun.mtu) print hexlify(buf[4:]) IPpayload = buf[4:] # TODO encrypt buf # TODO send to wlan0 # TODO enable routing except KeyboardInterrupt: tun.close()
Change shebang to use python from environment. Fix Indentation.
#!/usr/bin/env python from pytun import TunTapDevice from binascii import hexlify if __name__ == '__main__': tun = TunTapDevice(name='ipsec-tun') tun.up() tun.persist(True) while True: try: buf = tun.read(tun.mtu) print hexlify(buf[4:]) IPpayload = buf[4:] # TODO encrypt buf # TODO send to wlan0 # TODO enable routing except KeyboardInterrupt: tun.close()
import frappe from frappe.model.rename_doc import rename_doc def execute(): if frappe.db.exists("DocType", "Desk Page"): if frappe.db.exists('DocType', 'Workspace'): # this patch was not added initially, so this page might still exist frappe.delete_doc('DocType', 'Desk Page') else: rename_doc('DocType', 'Desk Page', 'Workspace') rename_doc('DocType', 'Desk Chart', 'Workspace Chart', ignore_if_exists=True) rename_doc('DocType', 'Desk Link', 'Workspace Link', ignore_if_exists=True) rename_doc('DocType', 'Desk Shortcut', 'Workspace Shortcut', ignore_if_exists=True) frappe.reload_doc('desk', 'doctype', 'workspace')
fix(Patch): Rename Desk Link only if it exists
import frappe from frappe.model.rename_doc import rename_doc def execute(): if frappe.db.exists("DocType", "Desk Page"): if frappe.db.exists('DocType', 'Workspace'): # this patch was not added initially, so this page might still exist frappe.delete_doc('DocType', 'Desk Page') else: rename_doc('DocType', 'Desk Page', 'Workspace') rename_doc('DocType', 'Desk Chart', 'Workspace Chart', ignore_if_exists=True) rename_doc('DocType', 'Desk Shortcut', 'Workspace Shortcut', ignore_if_exists=True) if frappe.db.exist('DocType', 'Desk Link'): rename_doc('DocType', 'Desk Link', 'Workspace Link', ignore_if_exists=True) frappe.reload_doc('desk', 'doctype', 'workspace')
#!/usr/bin/env python from gevent.wsgi import WSGIServer import werkzeug.serving from werkzeug.debug import DebuggedApplication from app import get_app APP_PORT = 5000 DEBUG = True @werkzeug.serving.run_with_reloader def main(): """Starts web application """ app = get_app() app.debug = DEBUG # app.config['ASSETS_DEBUG'] = DEBUG http_server = WSGIServer(('', APP_PORT), DebuggedApplication(app, evalex=True)) http_server.serve_forever() # app.run() if __name__ == '__main__': print('purkinje ready') main()
Apply gevent monkey patching, so it will get invoked when main is called via the entry point script and not via shell script
#!/usr/bin/env python import gevent.monkey gevent.monkey.patch_all() from gevent.wsgi import WSGIServer import werkzeug.serving from werkzeug.debug import DebuggedApplication from app import get_app APP_PORT = 5000 DEBUG = True @werkzeug.serving.run_with_reloader def main(): """Starts web application """ app = get_app() app.debug = DEBUG # app.config['ASSETS_DEBUG'] = DEBUG http_server = WSGIServer(('', APP_PORT), DebuggedApplication(app, evalex=True)) http_server.serve_forever() # app.run() if __name__ == '__main__': print('purkinje ready') main()
"""Utiltiy functions for workign on the NinaPro Databases (1 & 2).""" from setuptools import setup, find_packages setup(name='nina_helper', version='2.1', description='Utiltiy functions for workign on the NinaPro Databases (1 & 2)', author='Lif3line', author_email='[email protected]', license='MIT', packages=find_packages(), url='https://github.com/Lif3line/nina_helper_package_mk2', # use the URL to the github repo download_url='https://github.com/Lif3line/nina_helper_package_mk2/archive/2.1.tar.gz', # Hack github address install_requires=[ 'os', 'scipy', 'sklearn', 'itertools', 'numpy' ], keywords='ninapro emg')
Use local upload for release
"""Utiltiy functions for workign on the NinaPro Databases (1 & 2).""" from setuptools import setup, find_packages setup(name='nina_helper', version='2.2', description='Utiltiy functions for workign on the NinaPro Databases (1 & 2)', author='Lif3line', author_email='[email protected]', license='MIT', packages=find_packages(), url='https://github.com/Lif3line/nina_helper_package_mk2', # use the URL to the github repo # download_url='https://github.com/Lif3line/nina_helper_package_mk2/archive/2.2.tar.gz', # Hack github address install_requires=[ 'scipy', 'sklearn', 'numpy' ], keywords='ninapro emg')
import logging from django.test import TestCase, RequestFactory from log_request_id.middleware import RequestIDMiddleware from testproject.views import test_view class RequestIDLoggingTestCase(TestCase): def setUp(self): self.factory = RequestFactory() self.handler = logging.getLogger('testproject').handlers[0] def test_id_generation(self): request = self.factory.get('/') middleware = RequestIDMiddleware() middleware.process_request(request) self.assertTrue(hasattr(request, 'id')) test_view(request) self.assertTrue(request.id in self.handler.messages[0])
Add test for externally-generated request IDs
import logging from django.test import TestCase, RequestFactory from log_request_id.middleware import RequestIDMiddleware from testproject.views import test_view class RequestIDLoggingTestCase(TestCase): def setUp(self): self.factory = RequestFactory() self.handler = logging.getLogger('testproject').handlers[0] self.handler.messages = [] def test_id_generation(self): request = self.factory.get('/') middleware = RequestIDMiddleware() middleware.process_request(request) self.assertTrue(hasattr(request, 'id')) test_view(request) self.assertTrue(request.id in self.handler.messages[0]) def test_external_id_in_http_header(self): with self.settings(LOG_REQUEST_ID_HEADER='REQUEST_ID_HEADER'): request = self.factory.get('/') request.META['REQUEST_ID_HEADER'] = 'some_request_id' middleware = RequestIDMiddleware() middleware.process_request(request) self.assertEqual(request.id, 'some_request_id') test_view(request) self.assertTrue('some_request_id' in self.handler.messages[0])
import eventlet import os import sys from oslo.config import cfg from st2common import log as logging from st2common.models.db import db_setup from st2common.models.db import db_teardown from st2actions import config from st2actions import history LOG = logging.getLogger(__name__) eventlet.monkey_patch( os=True, select=True, socket=True, thread=False if '--use-debugger' in sys.argv else True, time=True) def _setup(): # Parse args to setup config. config.parse_args() # Setup logging. logging.setup(cfg.CONF.history.logging) # All other setup which requires config to be parsed and logging to be correctly setup. db_setup(cfg.CONF.database.db_name, cfg.CONF.database.host, cfg.CONF.database.port) def _run_worker(): LOG.info('(PID=%s) History worker started.', os.getpid()) try: history.work() except (KeyboardInterrupt, SystemExit): LOG.info('(PID=%s) History worker stopped.', os.getpid()) except: return 1 return 0 def _teardown(): db_teardown() def main(): try: _setup() return _run_worker() except: LOG.exception('(PID=%s) History worker quit due to exception.', os.getpid()) return 1 finally: _teardown()
Move code from _run_worker into main
import eventlet import os import sys from oslo.config import cfg from st2common import log as logging from st2common.models.db import db_setup from st2common.models.db import db_teardown from st2actions import config from st2actions import history LOG = logging.getLogger(__name__) eventlet.monkey_patch( os=True, select=True, socket=True, thread=False if '--use-debugger' in sys.argv else True, time=True) def _setup(): # Parse args to setup config. config.parse_args() # Setup logging. logging.setup(cfg.CONF.history.logging) # All other setup which requires config to be parsed and logging to be correctly setup. db_setup(cfg.CONF.database.db_name, cfg.CONF.database.host, cfg.CONF.database.port) def _teardown(): db_teardown() def main(): try: _setup() LOG.info('(PID=%s) Historian started.', os.getpid()) history.work() except (KeyboardInterrupt, SystemExit): LOG.info('(PID=%s) Historian stopped.', os.getpid()) return 0 except: LOG.exception('(PID=%s) Historian quit due to exception.', os.getpid()) return 1 finally: _teardown() return 0
from __future__ import absolute_import from __future__ import unicode_literals from casexml.apps.case.models import CommCareCase from dimagi.utils.parsing import json_format_datetime def get_case_ids_modified_with_owner_since(domain, owner_id, reference_date): """ Gets all cases with a specified owner ID that have been modified since a particular reference_date (using the server's timestamp) """ return [ row['id'] for row in CommCareCase.get_db().view( 'cases_by_server_date/by_owner_server_modified_on', startkey=[domain, owner_id, json_format_datetime(reference_date)], endkey=[domain, owner_id, {}], include_docs=False, reduce=False ) ]
Make get_case_ids_modified_with_owner_since accept an end date as well
from __future__ import absolute_import from __future__ import unicode_literals from casexml.apps.case.models import CommCareCase from dimagi.utils.parsing import json_format_datetime def get_case_ids_modified_with_owner_since(domain, owner_id, reference_date, until_date=None): """ Gets all cases with a specified owner ID that have been modified since a particular reference_date (using the server's timestamp) """ return [ row['id'] for row in CommCareCase.get_db().view( 'cases_by_server_date/by_owner_server_modified_on', startkey=[domain, owner_id, json_format_datetime(reference_date)], endkey=[domain, owner_id, {} if not until_date else json_format_datetime(until_date)], include_docs=False, reduce=False ) ]
Allow django-money to be specified as read-only in a model Monkey patch the Django admin so that we can display django-money fields read-only. In order to do this, we simply catch the exception that results from trying to convert a money object (e.g. '10 USD') into a floating field. And then we call just ask for the string representation of the field.
from django.db import models from django.utils.encoding import smart_unicode from django.utils import formats from django.utils import timezone from django.core.exceptions import ObjectDoesNotExist from django.contrib.admin.util import lookup_field from django.utils.safestring import mark_safe from django.utils.html import conditional_escape from django.db.models.fields.related import ManyToManyRel from django.contrib.admin import util as admin_util def djmoney_display_for_field(value, field): from django.contrib.admin.templatetags.admin_list import _boolean_icon from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE try: if field.flatchoices: return dict(field.flatchoices).get(value, EMPTY_CHANGELIST_VALUE) # NullBooleanField needs special-case null-handling, so it comes # before the general null test. elif isinstance(field, models.BooleanField) or isinstance(field, models.NullBooleanField): return _boolean_icon(value) elif value is None: return EMPTY_CHANGELIST_VALUE elif isinstance(field, models.DateTimeField): return formats.localize(timezone.localtime(value)) elif isinstance(field, models.DateField) or isinstance(field, models.TimeField): return formats.localize(value) elif isinstance(field, models.DecimalField): return formats.number_format(value, field.decimal_places) elif isinstance(field, models.FloatField): return formats.number_format(value) else: return smart_unicode(value) except: return smart_unicode(value) admin_util.display_for_field = djmoney_display_for_field def djmoney_contents(self): from django.contrib.admin.templatetags.admin_list import _boolean_icon from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin try: f, attr, value = lookup_field(field, obj, model_admin) except (AttributeError, ValueError, ObjectDoesNotExist): result_repr = EMPTY_CHANGELIST_VALUE else: if f is None: boolean = getattr(attr, "boolean", False) if boolean: result_repr = _boolean_icon(value) else: result_repr = smart_unicode(value) if getattr(attr, "allow_tags", False): result_repr = mark_safe(result_repr) else: if value is None: result_repr = EMPTY_CHANGELIST_VALUE elif isinstance(f.rel, ManyToManyRel): result_repr = ", ".join(map(unicode, value.all())) else: result_repr = djmoney_display_for_field(value, f) return conditional_escape(result_repr) from django.contrib.admin.helpers import AdminReadonlyField AdminReadonlyField.contents = djmoney_contents
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.conf.urls import patterns, url from .views import HomePageView, FormHorizontalView, FormInlineView, PaginationView, FormWithFilesView, \ DefaultFormView, MiscView, DefaultFormsetView, DefaultFormByFieldView urlpatterns = [ url(r'^$', HomePageView.as_view(), name='home'), url(r'^formset$', DefaultFormsetView.as_view(), name='formset_default'), url(r'^form$', DefaultFormView.as_view(), name='form_default'), url(r'^form_by_field$', DefaultFormByFieldView.as_view(), name='form_by_field'), url(r'^form_horizontal$', FormHorizontalView.as_view(), name='form_horizontal'), url(r'^form_inline$', FormInlineView.as_view(), name='form_inline'), url(r'^form_with_files$', FormWithFilesView.as_view(), name='form_with_files'), url(r'^pagination$', PaginationView.as_view(), name='pagination'), url(r'^misc$', MiscView.as_view(), name='misc'), ]
Remove obsolete import (removed in Django 1.10)
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.conf.urls import url from .views import HomePageView, FormHorizontalView, FormInlineView, PaginationView, FormWithFilesView, \ DefaultFormView, MiscView, DefaultFormsetView, DefaultFormByFieldView urlpatterns = [ url(r'^$', HomePageView.as_view(), name='home'), url(r'^formset$', DefaultFormsetView.as_view(), name='formset_default'), url(r'^form$', DefaultFormView.as_view(), name='form_default'), url(r'^form_by_field$', DefaultFormByFieldView.as_view(), name='form_by_field'), url(r'^form_horizontal$', FormHorizontalView.as_view(), name='form_horizontal'), url(r'^form_inline$', FormInlineView.as_view(), name='form_inline'), url(r'^form_with_files$', FormWithFilesView.as_view(), name='form_with_files'), url(r'^pagination$', PaginationView.as_view(), name='pagination'), url(r'^misc$', MiscView.as_view(), name='misc'), ]
import pytest from pyhocon.config_tree import ConfigTree from pyhocon.exceptions import ConfigMissingException, ConfigWrongTypeException class TestConfigParser(object): def test_config_tree_quoted_string(self): config_tree = ConfigTree() config_tree.put("a.b.c", "value") assert config_tree.get("a.b.c") == "value" with pytest.raises(ConfigMissingException): assert config_tree.get("a.b.d") with pytest.raises(ConfigMissingException): config_tree.get("a.d.e") with pytest.raises(ConfigWrongTypeException): config_tree.get("a.b.c.e") def test_config_tree_number(self): config_tree = ConfigTree() config_tree.put("a.b.c", 5) assert config_tree.get("a.b.c") == 5
Add failing tests for iteration and logging config
import pytest from pyhocon.config_tree import ConfigTree from pyhocon.exceptions import ConfigMissingException, ConfigWrongTypeException class TestConfigParser(object): def test_config_tree_quoted_string(self): config_tree = ConfigTree() config_tree.put("a.b.c", "value") assert config_tree.get("a.b.c") == "value" with pytest.raises(ConfigMissingException): assert config_tree.get("a.b.d") with pytest.raises(ConfigMissingException): config_tree.get("a.d.e") with pytest.raises(ConfigWrongTypeException): config_tree.get("a.b.c.e") def test_config_tree_number(self): config_tree = ConfigTree() config_tree.put("a.b.c", 5) assert config_tree.get("a.b.c") == 5 def test_config_tree_iterator(self): config_tree = ConfigTree() config_tree.put("a.b.c", 5) for k in config_tree: assert k == "a" assert config_tree[k]["b.c"] == 5 def test_config_logging(self): import logging, logging.config config_tree = ConfigTree() config_tree.put('version', 1) config_tree.put('root.level', logging.INFO) assert dict(config_tree)['version'] == 1 logging.config.dictConfig(config_tree)
"""Little helper application to improve django choices (for fields)""" from __future__ import unicode_literals from .choices import Choices __author__ = 'Stephane "Twidi" Ange;' __contact__ = "[email protected]" __homepage__ = "https://pypi.python.org/pypi/django-extended-choices" __version__ = "1.1"
Make OrderedChoices available at the package root
"""Little helper application to improve django choices (for fields)""" from __future__ import unicode_literals from .choices import Choices, OrderedChoices __author__ = 'Stephane "Twidi" Ange;' __contact__ = "[email protected]" __homepage__ = "https://pypi.python.org/pypi/django-extended-choices" __version__ = "1.1"
from functools import wraps from django.db import connection def auto_close_db(f): "Ensures the database connection is closed when the function returns." @wraps(f) def wrapper(*args, **kwargs): try: return f(*args, **kwargs) finally: connection.close() return wrapper
Fix circular import when used with other add-ons that import django.db eg sorl_thumbnail: Traceback (most recent call last): File "/home/rpatterson/src/work/retrans/src/ReTransDjango/bin/manage", line 40, in <module> sys.exit(manage.main()) File "/home/rpatterson/src/work/retrans/src/ReTransDjango/retrans/manage.py", line 15, in main execute_manager(settings) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/core/management/__init__.py", line 438, in execute_manager utility.execute() File "/opt/src/eggs/Django-1.3-py2.7.egg/django/core/management/__init__.py", line 379, in execute self.fetch_command(subcommand).run_from_argv(self.argv) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/core/management/base.py", line 191, in run_from_argv self.execute(*args, **options.__dict__) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/core/management/base.py", line 209, in execute translation.activate('en-us') File "/opt/src/eggs/Django-1.3-py2.7.egg/django/utils/translation/__init__.py", line 100, in activate return _trans.activate(language) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/utils/translation/trans_real.py", line 202, in activate _active.value = translation(language) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/utils/translation/trans_real.py", line 185, in translation default_translation = _fetch(settings.LANGUAGE_CODE) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/utils/translation/trans_real.py", line 162, in _fetch app = import_module(appname) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/utils/importlib.py", line 35, in import_module __import__(name) File "/opt/src/eggs/sorl_thumbnail-11.12-py2.7.egg/sorl/thumbnail/__init__.py", line 1, in <module> from sorl.thumbnail.fields import ImageField File "/opt/src/eggs/sorl_thumbnail-11.12-py2.7.egg/sorl/thumbnail/fields.py", line 2, in <module> from django.db import models File "/opt/src/eggs/Django-1.3-py2.7.egg/django/db/__init__.py", line 78, in <module> connection = connections[DEFAULT_DB_ALIAS] File "/opt/src/eggs/Django-1.3-py2.7.egg/django/db/utils.py", line 94, in __getitem__ backend = load_backend(db['ENGINE']) File "/opt/src/eggs/Django-1.3-py2.7.egg/django/db/utils.py", line 47, in load_backend if backend_name not in available_backends: django.core.exceptions.ImproperlyConfigured: 'django_mysqlpool.backends.mysqlpool' isn't an available database backend. Try using django.db.backends.XXX, where XXX is one of: 'dummy', 'mysql', 'oracle', 'postgresql', 'postgresql_psycopg2', 'sqlite3' Error was: cannot import name connection
from functools import wraps def auto_close_db(f): "Ensures the database connection is closed when the function returns." from django.db import connection @wraps(f) def wrapper(*args, **kwargs): try: return f(*args, **kwargs) finally: connection.close() return wrapper
#!/usr/bin/env python from twisted.web.server import Site from webtest.session import RedisSessionFactory from webtest.request import RedisRequest from webtest import log logger = log.get_logger() class RedisSite(Site): sessionFactory = RedisSessionFactory requestFactory = RedisRequest def makeSession(self): """ Generate a new Session instance """ uid = self._mkuid() return self.sessionFactory.retrieve(uid, reactor=self._reactor) def getSession(self, uid): """ Get a previously generated session, by its unique ID. This raises a KeyError if the session is not found. """ return self.sessionFactory.retrieve(uid, reactor=self._reactor)
Move RedisSessionFactory into its own module
#!/usr/bin/env python from twisted.web.server import Site from webtest.session_factory import RedisSessionFactory from webtest.request import RedisRequest from webtest import log logger = log.get_logger() class RedisSite(Site): sessionFactory = RedisSessionFactory requestFactory = RedisRequest def makeSession(self): """ Generate a new Session instance """ uid = self._mkuid() return self.sessionFactory.retrieve(uid, reactor=self._reactor) def getSession(self, uid): """ Get a previously generated session, by its unique ID. This raises a KeyError if the session is not found. """ return self.sessionFactory.retrieve(uid, reactor=self._reactor)
class LocalNodeMiddleware(object): """ Ensures a Node that represents the local server always exists. No other suitable hook for code that's run once and can access the server's host name was found. A migration was not suitable for the second reason. """ def __init__(self): self.local_node_created = False def process_request(self, request): if not self.local_node_created: from dashboard.models import Node nodes = Node.objects.filter(local=True) host = "http://" + request.get_host() if host[-1] != "/": host += "/" service = host + "service/" if len(nodes) == 0: node = Node(name="Local", website_url=host, service_url=service, local=True) node.save() elif len(nodes) == 1: node = nodes[0] node.host = host node.service = service node.save() else: raise RuntimeError("More than one local node found in Nodes table. Please fix before continuing.") self.local_node_created = True return None
Add TODO to fix bug at later date
class LocalNodeMiddleware(object): """ Ensures a Node that represents the local server always exists. No other suitable hook for code that's run once and can access the server's host name was found. A migration was not suitable for the second reason. """ def __init__(self): self.local_node_created = False def process_request(self, request): if not self.local_node_created: from dashboard.models import Node nodes = Node.objects.filter(local=True) host = "http://" + request.get_host() if host[-1] != "/": host += "/" service = host + "service/" if len(nodes) == 0: node = Node(name="Local", website_url=host, service_url=service, local=True) node.save() elif len(nodes) == 1: node = nodes[0] node.host = host node.service = service # TODO: Fix bug that prevents this from actually saving node.save() else: raise RuntimeError("More than one local node found in Nodes table. Please fix before continuing.") self.local_node_created = True return None
from eve import Eve app = Eve() if __name__ == '__main__': app.run()
Use port 80 to serve the API
from eve import Eve app = Eve() if __name__ == '__main__': app.run(host='0.0.0.0', port=80)
from rest_framework import serializers from registries.models import Organization from gwells.models import ProvinceState class DrillerListSerializer(serializers.ModelSerializer): province_state = serializers.ReadOnlyField() class Meta: model = Organization # Using all fields for now fields = ( #'who_created', #'when_created', #'who_updated', #'when_updated', 'name', 'street_address', 'city', 'province_state', 'postal_code', 'main_tel', 'fax_tel', 'website_url', 'certificate_authority', )
Add fields to driller list serializer
from rest_framework import serializers from registries.models import Organization from gwells.models import ProvinceState class DrillerListSerializer(serializers.ModelSerializer): """ Serializer for Driller model "list" view. """ province_state = serializers.ReadOnlyField(source="province_state.code") class Meta: model = Organization # Using all fields for now fields = ( #'who_created', #'when_created', #'who_updated', #'when_updated', 'org_guid', 'name', 'street_address', 'city', 'province_state', 'postal_code', 'main_tel', #'fax_tel', #'website_url', #'certificate_authority', )
from django.conf import settings def add_settings( request ): """Add some selected settings values to the context""" return { 'settings': { 'GOOGLE_ANALYTICS_ACCOUNT': settings.GOOGLE_ANALYTICS_ACCOUNT, } }
Make settings.DEBUG available to templates It's used in the default base.html template so makes sense for it to actually appear in the context.
from django.conf import settings def add_settings( request ): """Add some selected settings values to the context""" return { 'settings': { 'GOOGLE_ANALYTICS_ACCOUNT': settings.GOOGLE_ANALYTICS_ACCOUNT, 'DEBUG': settings.DEBUG, } }
#!/usr/bin/python import os import sys import api import json import getpass # Banks banks = {} import bankofamerica banks["bankofamerica"] = bankofamerica print "Login" print "Username: ", username = sys.stdin.readline().strip() password = getpass.getpass() if not api.callapi("login",{"username": username, "password": password}): print "Login failed" sys.exit(1) todo = api.callapi("accountstodo") for account in todo: if account["bankname"] not in banks: print "No scraper for %s!" % (account["bankname"]) continue print "Scraping %s..." % (account["bankname"]) if os.getenv("DATAFILE"): data = open(os.getenv("DATAFILE")).read() else: data = json.dumps(banks[account["bankname"]].downloadaccount(account),default=str) api.callapi("newtransactions", {"data": data}) api.callapi("logout")
Read bank list from config file.
#!/usr/bin/python import os import sys import api import json import getpass sys.path.append("../") import config # Banks banks = {} for bank in config.banks: exec "import %s" % (bank) banks[bank] = eval(bank) print "Login" print "Username: ", username = sys.stdin.readline().strip() password = getpass.getpass() if not api.callapi("login",{"username": username, "password": password}): print "Login failed" sys.exit(1) todo = api.callapi("accountstodo") for account in todo: if account["bankname"] not in banks: print "No scraper for %s!" % (account["bankname"]) continue print "Scraping %s..." % (account["bankname"]) if os.getenv("DATAFILE"): data = open(os.getenv("DATAFILE")).read() else: data = json.dumps(banks[account["bankname"]].downloadaccount(account),default=str) api.callapi("newtransactions", {"data": data}) api.callapi("logout")
# Taken from txircd: # https://github.com/ElementalAlchemist/txircd/blob/8832098149b7c5f9b0708efe5c836c8160b0c7e6/txircd/utils.py#L9 def _enum(**enums): return type('Enum', (), enums) ModeType = _enum(LIST=0, PARAM_SET=1, PARAM_UNSET=2, NO_PARAM=3) ModuleLoadType = _enum(LOAD=0, UNLOAD=1, ENABLE=2, DISABLE=3) def isNumber(s): try: float(s) return True except ValueError: return False def parseUserPrefix(prefix): if "!" in prefix: nick = prefix[:prefix.find("!")] ident = prefix[prefix.find("!") + 1:prefix.find("@")] host = prefix[prefix.find("@") + 1:] return nick, ident, host # Not all "users" have idents and hostnames nick = prefix return nick, None, None def networkName(bot, server): return bot.servers[server].supportHelper.network
Fix the handling of missing prefixes Twisted defaults to an empty string, while IRCBase defaults to None.
# Taken from txircd: # https://github.com/ElementalAlchemist/txircd/blob/8832098149b7c5f9b0708efe5c836c8160b0c7e6/txircd/utils.py#L9 def _enum(**enums): return type('Enum', (), enums) ModeType = _enum(LIST=0, PARAM_SET=1, PARAM_UNSET=2, NO_PARAM=3) ModuleLoadType = _enum(LOAD=0, UNLOAD=1, ENABLE=2, DISABLE=3) def isNumber(s): try: float(s) return True except ValueError: return False def parseUserPrefix(prefix): if prefix is None: prefix = "" if "!" in prefix: nick = prefix[:prefix.find("!")] ident = prefix[prefix.find("!") + 1:prefix.find("@")] host = prefix[prefix.find("@") + 1:] return nick, ident, host # Not all "users" have idents and hostnames nick = prefix return nick, None, None def networkName(bot, server): return bot.servers[server].supportHelper.network
# -*- coding: utf-8 -*- # # (c) 2014 Bjoern Ricks <[email protected]> # # See LICENSE comming with the source of 'trex' for details. # from rest_framework.serializers import HyperlinkedModelSerializer from trex.models.project import Project class ProjectSerializer(HyperlinkedModelSerializer): class Meta: model = Project fields = ("url", "name", "description", "active", "created")
Add a ProjectDetailSerializer and EntryDetailSerializer
# -*- coding: utf-8 -*- # # (c) 2014 Bjoern Ricks <[email protected]> # # See LICENSE comming with the source of 'trex' for details. # from rest_framework.serializers import HyperlinkedModelSerializer from trex.models.project import Project, Entry class ProjectSerializer(HyperlinkedModelSerializer): class Meta: model = Project fields = ("url", "name", "description", "active", "created") class ProjectDetailSerializer(HyperlinkedModelSerializer): class Meta: model = Project fields = ("name", "description", "active", "created", "entries") class EntryDetailSerializer(HyperlinkedModelSerializer): class Meta: model = Entry fields = ("date", "duration", "description", "state", "user", "created")
from utils import models class Plugin: plugin_name = None display_name = None description = None author = None short_name = None stage = None manager_url = None version = None janeway_version = None is_workflow_plugin = False jump_url = None handshake_url = None article_pk_in_handshake_url = False press_wide = False kanban_card = '{plugin_name}/kanban_card.html'.format( plugin_name=plugin_name, ) @classmethod def install(cls): plugin, created = cls.get_or_create_plugin_object() if not created and plugin.version != cls.version: plugin.version = cls.version plugin.save() return plugin, created @classmethod def hook_registry(cls): pass @classmethod def get_or_create_plugin_object(cls): plugin, created = models.Plugin.objects.get_or_create( name=cls.short_name, display_name=cls.display_name, press_wide=cls.press_wide, defaults={'version': cls.version, 'enabled': True}, ) return plugin, created
Add get_self and change get_or_create to avoid mis-creation.
from utils import models class Plugin: plugin_name = None display_name = None description = None author = None short_name = None stage = None manager_url = None version = None janeway_version = None is_workflow_plugin = False jump_url = None handshake_url = None article_pk_in_handshake_url = False press_wide = False kanban_card = '{plugin_name}/kanban_card.html'.format( plugin_name=plugin_name, ) @classmethod def install(cls): plugin, created = cls.get_or_create_plugin_object() if not created and plugin.version != cls.version: print('Plugin updated: {0} -> {1}'.format(cls.version, plugin.version)) plugin.version = cls.version plugin.save() return plugin, created @classmethod def hook_registry(cls): pass @classmethod def get_or_create_plugin_object(cls): plugin, created = models.Plugin.objects.get_or_create( name=cls.short_name, defaults={ 'display_name': cls.display_name, 'version': cls.version, 'enabled': True, 'press_wide': cls.press_wide, }, ) return plugin, created @classmethod def get_self(cls): try: plugin = models.Plugin.objects.get( name=cls.short_name, ) except models.Plugin.MultipleObjectsReturned: plugin = models.Plugin.objects.filter( name=cls.short_name, ).order_by( '-version' ).first() except models.Plugin.DoesNotExist: return None return plugin
import csv ppelm_s3_key = '' def process_from_dump(fname=None, delimiter='\t'): ppelm_json = [] if fname is None: # ToDo Get from S3 pass else: with open(fname, 'r') as f: csv_reader = csv.reader(f.readlines(), delimiter=delimiter) columns = next(csv_reader) for entry in csv_reader: row_dict = {columns[n]: entry[n] for n in range(len(columns))} ppelm_json.append(row_dict) return ppelm_json
Move iterator to own function
import csv ppelm_s3_key = '' def process_from_dump(fname=None, delimiter='\t'): if fname is None: # ToDo Get from S3 return [] else: with open(fname, 'r') as f: csv_reader = csv.reader(f.readlines(), delimiter=delimiter) ppelm_json = _get_json_from_entry_rows(csv_reader) return ppelm_json def _get_json_from_entry_rows(row_iter): ppelm_json = [] columns = next(row_iter) for entry in row_iter: row_dict = {columns[n]: entry[n] for n in range(len(columns))} ppelm_json.append(row_dict) return ppelm_json
class Neuron: pass class NeuronNetwork: neurons = []
Create 2D list of Neurons in NeuronNetwork's init
class Neuron: pass class NeuronNetwork: neurons = [] def __init__(self, rows, columns): self.neurons = [] for row in xrange(rows): self.neurons.append([]) for column in xrange(columns): self.neurons[row].append(Neuron())
from distutils.core import setup from setuptools import find_packages setup(name='geventconnpool', version = "0.1", description = 'TCP connection pool for gevent', url="https://github.com/rasky/geventconnpool", author="Giovanni Bajo", author_email="[email protected]", packages=find_packages('src'), package_dir={'': 'src'}, include_package_data=True, install_requires=[ 'gevent >= 0.13' ], classifiers=[ "Development Status :: 4 - Beta", "Environment :: No Input/Output (Daemon)", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Natural Language :: English", "Operating System :: OS Independent", "Programming Language :: Python :: 2", "Topic :: Software Development", ])
Add long description to the package.
from distutils.core import setup from setuptools import find_packages with open('README.rst') as file: long_description = file.read() setup(name='geventconnpool', version = "0.1a", description = 'TCP connection pool for gevent', long_description = long_description, url="https://github.com/rasky/geventconnpool", author="Giovanni Bajo", author_email="[email protected]", packages=find_packages('src'), package_dir={'': 'src'}, include_package_data=True, install_requires=[ 'gevent >= 0.13' ], classifiers=[ "Development Status :: 4 - Beta", "Environment :: No Input/Output (Daemon)", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Natural Language :: English", "Operating System :: OS Independent", "Programming Language :: Python :: 2", "Topic :: Software Development", ])
""" Py-Tree-sitter """ import platform from setuptools import setup, Extension setup( name = "tree_sitter", version = "0.0.8", maintainer = "Max Brunsfeld", maintainer_email = "[email protected]", author = "Max Brunsfeld", author_email = "[email protected]", url = "https://github.com/tree-sitter/py-tree-sitter", license = "MIT", platforms = ["any"], python_requires = ">=3.3", description = "Python bindings to the Tree-sitter parsing library", classifiers = [ "License :: OSI Approved :: MIT License", "Topic :: Software Development :: Compilers", "Topic :: Text Processing :: Linguistic", ], packages = ['tree_sitter'], ext_modules = [ Extension( "tree_sitter_binding", [ "tree_sitter/core/lib/src/lib.c", "tree_sitter/binding.c", ], include_dirs = [ "tree_sitter/core/lib/include", "tree_sitter/core/lib/utf8proc", ], extra_compile_args = ( ['-std=c99'] if platform.system() != 'Windows' else None ) ) ], project_urls = { 'Source': 'https://github.com/tree-sitter/py-tree-sitter', 'Documentation': 'http://initd.org/psycopg/docs/', } )
Remove an incorrect documentation URL Fixes #9.
""" Py-Tree-sitter """ import platform from setuptools import setup, Extension setup( name = "tree_sitter", version = "0.0.8", maintainer = "Max Brunsfeld", maintainer_email = "[email protected]", author = "Max Brunsfeld", author_email = "[email protected]", url = "https://github.com/tree-sitter/py-tree-sitter", license = "MIT", platforms = ["any"], python_requires = ">=3.3", description = "Python bindings to the Tree-sitter parsing library", classifiers = [ "License :: OSI Approved :: MIT License", "Topic :: Software Development :: Compilers", "Topic :: Text Processing :: Linguistic", ], packages = ['tree_sitter'], ext_modules = [ Extension( "tree_sitter_binding", [ "tree_sitter/core/lib/src/lib.c", "tree_sitter/binding.c", ], include_dirs = [ "tree_sitter/core/lib/include", "tree_sitter/core/lib/utf8proc", ], extra_compile_args = ( ['-std=c99'] if platform.system() != 'Windows' else None ) ) ], project_urls = { 'Source': 'https://github.com/tree-sitter/py-tree-sitter', } )
from setuptools import setup, find_packages setup( name='bfg9000', version='0.1.0pre', license='BSD', author='Jim Porter', author_email='[email protected]', packages=find_packages(exclude=['test']), entry_points={ 'console_scripts': ['bfg9000=bfg9000.driver:main'], }, test_suite='test', )
Fix version number to comply with PEP 440
from setuptools import setup, find_packages setup( name='bfg9000', version='0.1.0-dev', license='BSD', author='Jim Porter', author_email='[email protected]', packages=find_packages(exclude=['test']), entry_points={ 'console_scripts': ['bfg9000=bfg9000.driver:main'], }, test_suite='test', )
from setuptools import find_packages, setup setup( name='txkazoo', version='0.0.4', description='Twisted binding for Kazoo', maintainer='Manish Tomar', maintainer_email='[email protected]', license='Apache 2.0', packages=find_packages(), install_requires=['twisted==13.2.0', 'kazoo==2.0b1'] )
Add long_description from README + URL
from setuptools import find_packages, setup setup( name='txkazoo', version='0.0.4', description='Twisted binding for Kazoo', long_description=open("README.md").read(), url="https://github.com/rackerlabs/txkazoo", maintainer='Manish Tomar', maintainer_email='[email protected]', license='Apache 2.0', packages=find_packages(), install_requires=['twisted==13.2.0', 'kazoo==2.0b1'] )
import importlib from cx_Freeze import setup, Executable backend_path = importlib.import_module("bcrypt").__path__[0] backend_path = backend_path.replace("bcrypt", ".libs_cffi_backend") # Dependencies are automatically detected, but it might need # fine tuning. build_exe_options = { "include_files": [ ("client/dist", "client"), "LICENSE", "templates", "readme.md", (backend_path, "lib/.libs_cffi_backend") ], "includes": [ "cffi", "numpy", "numpy.core._methods", "numpy.lib", "numpy.lib.format" ], "namespace_packages": [ "virtool" ], "packages": [ "_cffi_backend", "appdirs", "asyncio", "bcrypt", "cffi", "idna", "motor", "packaging", "uvloop" ] } options = { "build_exe": build_exe_options } executables = [ Executable('run.py', base="Console") ] importlib.import_module("virtool") setup(name='virtool', executables=executables, options=options)
Fix missing raven.processors in build
import importlib from cx_Freeze import setup, Executable backend_path = importlib.import_module("bcrypt").__path__[0] backend_path = backend_path.replace("bcrypt", ".libs_cffi_backend") # Dependencies are automatically detected, but it might need # fine tuning. build_exe_options = { "include_files": [ ("client/dist", "client"), "LICENSE", "templates", "readme.md", (backend_path, "lib/.libs_cffi_backend") ], "includes": [ "cffi", "numpy", "numpy.core._methods", "numpy.lib", "numpy.lib.format" "raven.processors" "namespace_packages": [ "virtool" ], "packages": [ "_cffi_backend", "appdirs", "asyncio", "bcrypt", "cffi", "idna", "motor", "packaging", "uvloop" ] } options = { "build_exe": build_exe_options } executables = [ Executable('run.py', base="Console") ] importlib.import_module("virtool") setup(name='virtool', executables=executables, options=options)
from setuptools import setup from setuptools.command.test import test as TestCommand import sys class PyTest(TestCommand): def finalize_options(self): TestCommand.finalize_options(self) self.test_args = [] self.test_suite = True def run_tests(self): import pytest errcode = pytest.main(self.test_args) sys.exit(errcode) setup( name='msumastro', version='IXME', description='Process FITS files painlessly', long_description=(open('README.rst').read()), license='BSD 3-clause', author='Matt Craig', author_email='[email protected]', packages=['msumastro'], include_package_data=True, install_requires=['astropysics>=0.0.dev0', 'astropy', 'numpy'], extras_require={ 'testing': ['pytest', 'pytest-capturelog'] }, classifiers=['Development Status :: 4 - Beta', 'License :: OSI Approved :: BSD License', 'Programming Language :: Python :: 2 :: Only'] )
Add entry point for quick_add_keys_to_file
from setuptools import setup, find_packages from setuptools.command.test import test as TestCommand import sys class PyTest(TestCommand): def finalize_options(self): TestCommand.finalize_options(self) self.test_args = [] self.test_suite = True def run_tests(self): import pytest errcode = pytest.main(self.test_args) sys.exit(errcode) setup( name='msumastro', version='FIXME', description='Process FITS files painlessly', url='http://github.com/mwcraig/msumastro', long_description=(open('README.rst').read()), license='BSD 3-clause', author='Matt Craig', author_email='[email protected]', packages=find_packages(exclude=['tests*']), include_package_data=True, install_requires=['astropysics>=0.0.dev0', 'astropy', 'numpy'], extras_require={ 'testing': ['pytest>1.4', 'pytest-capturelog'], 'docs': ['numpydoc', 'sphinx-argparse'] }, entry_points={ 'console_scripts': [ ('quick_add_keys_to_file = ' 'msumastro.scripts.quick_add_keys_to_file:main') ] }, classifiers=['Development Status :: 4 - Beta', 'License :: OSI Approved :: BSD License', 'Programming Language :: Python :: 2 :: Only'] )
#!/usr/bin/env python import os from setuptools import find_packages, setup SCRIPT_DIR = os.path.dirname(__file__) if not SCRIPT_DIR: SCRIPT_DIR = os.getcwd() SRC_PREFIX = 'src' packages = find_packages(SRC_PREFIX) setup( name='cmdline', version='0.0.0', description='Utilities for consistent command line tools', author='Roberto Aguilar', author_email='[email protected]', package_dir={'': SRC_PREFIX}, packages=packages, long_description=open('README.md').read(), url='http://github.com/rca/cmdline', license='LICENSE', classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Natural Language :: English', 'Topic :: Utilities' ], install_requires=[ 'PyYAML>=3', ], )
Add markdown content type for README
#!/usr/bin/env python import os from setuptools import find_packages, setup SCRIPT_DIR = os.path.dirname(__file__) if not SCRIPT_DIR: SCRIPT_DIR = os.getcwd() SRC_PREFIX = 'src' def readme(): with open('README.md') as f: return f.read() packages = find_packages(SRC_PREFIX) setup( name='cmdline', version='0.0.0', description='Utilities for consistent command line tools', author='Roberto Aguilar', author_email='[email protected]', package_dir={'': SRC_PREFIX}, packages=packages, long_description=readme(), long_description_content_type='text/markdown', url='http://github.com/rca/cmdline', license='LICENSE', classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Natural Language :: English', 'Topic :: Utilities' ], install_requires=[ 'PyYAML>=3', ], )
import json import os import webapp2 from webapp2_extras import jinja2 class BaseHandler(webapp2.RequestHandler): @webapp2.cached_property def jinja2(self): return jinja2.get_jinja2(app=self.app) def render_template(self, filename, **template_args): self.response.write(self.jinja2.render_template(filename, **template_args)) class IndexHandler(BaseHandler): def get(self): self.render_template('index.html', name=self.request.get('name')) class RegistrationHandler(webapp2.RequestHandler): def post(self): json_object = json.loads(self.request.body) self.response.write('Registration Received {}'.format(json_object)) class GamesHandler(webapp2.RequestHandler): def post(self): self.response.write('Game Received') app = webapp2.WSGIApplication([ webapp2.Route('/', handler=IndexHandler, name='home', methods=['GET']), webapp2.Route('/register', handler=RegistrationHandler, name='registration', methods=['POST']), webapp2.Route('/games', handler=GamesHandler, name='games', methods=['POST']), ], debug=True)
Return Status 422 on bad JSON content
import json import os import webapp2 from webapp2_extras import jinja2 class BaseHandler(webapp2.RequestHandler): @webapp2.cached_property def jinja2(self): return jinja2.get_jinja2(app=self.app) def render_template(self, filename, **template_args): self.response.write(self.jinja2.render_template(filename, **template_args)) class IndexHandler(BaseHandler): def get(self): self.render_template('index.html', name=self.request.get('name')) class RegistrationHandler(webapp2.RequestHandler): def post(self): json_object = json.loads(self.request.body) if not 'username' in json_object: webapp2.abort(422, detail='Field "username" is required') else: self.response.write('Registration Received {}'.format(json_object)) class GamesHandler(webapp2.RequestHandler): def post(self): self.response.write('Game Received') app = webapp2.WSGIApplication([ webapp2.Route('/', handler=IndexHandler, name='home', methods=['GET']), webapp2.Route('/register', handler=RegistrationHandler, name='registration', methods=['POST']), webapp2.Route('/games', handler=GamesHandler, name='games', methods=['POST']), ], debug=True)
""" WSGI config for classicalguitar project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.7/howto/deployment/wsgi/ """ import os os.environ.setdefault("DJANGO_SETTINGS_MODULE", "classicalguitar.settings") from django.core.wsgi import get_wsgi_application from dj_static import Cling application = Cling(get_wsgi_application())
Correct some remaining classical guitar refs
""" WSGI config for website project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.7/howto/deployment/wsgi/ """ import os os.environ.setdefault("DJANGO_SETTINGS_MODULE", "website.settings") from django.core.wsgi import get_wsgi_application from dj_static import Cling application = Cling(get_wsgi_application())
""" ydf/yaml_ext ~~~~~~~~~~~~ Contains extensions to existing YAML functionality. """ import collections from ruamel import yaml from ruamel.yaml import resolver __all__ = ['load_all', 'load_all_gen'] class OrderedRoundTripLoader(yaml.RoundTripLoader): """ Extends the default round trip YAML loader to use :class:`~collections.OrderedDict` for mapping types. """ def __init__(self, *args, **kwargs): super(OrderedRoundTripLoader, self).__init__(*args, **kwargs) self.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, self.construct_ordered_mapping) @staticmethod def construct_ordered_mapping(loader, node): loader.flatten_mapping(node) return collections.OrderedDict(loader.construct_pairs(node)) def load_all(stream): """ Load all documents within the given YAML string. :param stream: A valid YAML stream. :return: List that contains all documents found in the YAML stream. """ return list(load_all_gen(stream)) def load_all_gen(stream): """ Load all documents within the given YAML string. :param stream: A valid YAML stream. :return: Generator that yields each document found in the YAML stream. """ return yaml.load_all(stream, OrderedRoundTripLoader)
Add YAML load for single document.
""" ydf/yaml_ext ~~~~~~~~~~~~ Contains extensions to existing YAML functionality. """ import collections from ruamel import yaml from ruamel.yaml import resolver __all__ = ['load', 'load_all', 'load_all_gen'] class OrderedRoundTripLoader(yaml.RoundTripLoader): """ Extends the default round trip YAML loader to use :class:`~collections.OrderedDict` for mapping types. """ def __init__(self, *args, **kwargs): super(OrderedRoundTripLoader, self).__init__(*args, **kwargs) self.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, self.construct_ordered_mapping) @staticmethod def construct_ordered_mapping(loader, node): loader.flatten_mapping(node) return collections.OrderedDict(loader.construct_pairs(node)) def load(stream): """ Load a single document within the given YAML string. :param stream: A valid YAML stream. :return: An :class:`~collections.OrderedDict` representation of the YAML stream. """ return yaml.load(stream, OrderedRoundTripLoader) def load_all(stream): """ Load all documents within the given YAML string. :param stream: A valid YAML stream. :return: List that contains all documents found in the YAML stream. """ return list(load_all_gen(stream)) def load_all_gen(stream): """ Load all documents within the given YAML string. :param stream: A valid YAML stream. :return: Generator that yields each document found in the YAML stream. """ return yaml.load_all(stream, OrderedRoundTripLoader)
#!/usr/bin/env python ''' Copyright (c) 2016 anti-XSS developers ''' import sys from lib.core.link import Link from optparse import OptionParser from lib.core.engine import getPage from lib.core.engine import getScript from lib.core.engine import xssScanner from lib.generator.report import gnrReport def main(): parser = OptionParser() parser.add_option('-u', '--url', dest='startUrl', help='Target URL (e.g. \'http://www.site.com/\')') parser.add_option('-d', '--depth', dest='depth', help='The depth you want to scan (default: 2)') (options, args) = parser.parse_args() if options.startUrl: rootLink = Link(options.startUrl, options.startUrl) if options.depth: getPage(rootLink, int(options.depth)) else: getPage(rootLink, 2) getScript() xssScanner() pass if __name__ == '__main__': main()
Add initialization before get url
#!/usr/bin/env python ''' Copyright (c) 2016 anti-XSS developers ''' import sys from lib.core.urlfun import * from lib.core.link import Link from optparse import OptionParser from lib.core.engine import getPage from lib.core.engine import getScript from lib.core.engine import xssScanner from lib.generator.report import gnrReport def main(): parser = OptionParser() parser.add_option('-u', '--url', dest='startUrl', help='Target URL (e.g. \'http://www.site.com/\')') parser.add_option('-d', '--depth', dest='depth', help='The depth you want to scan (default: 2)') (options, args) = parser.parse_args() if options.startUrl: url = initialize(options.startUrl) rootLink = Link(url, url) if options.depth: getPage(rootLink, int(options.depth)) else: getPage(rootLink, 2) getScript() xssScanner() pass if __name__ == '__main__': main()
def map_range(x, in_min, in_max, out_min, out_max): out_delta = out_max - out_min in_delta = in_max - in_min return (x - in_min) * out_delta / in_delta + out_min
Add function for linear interpolation (lerp)
def lerp(a, b, t): return (1.0 - t) * a + t * b def map_range(x, in_min, in_max, out_min, out_max): out_delta = out_max - out_min in_delta = in_max - in_min return (x - in_min) * out_delta / in_delta + out_min
# -*- coding: utf-8 -*- import sys import os from glob import glob # ------------------------------------------------------------------------- # Configure extensions extensions = [ 'sphinx.ext.autodoc', ] # ------------------------------------------------------------------------- # General configuration project = u'sphinxcontrib.traceables' copyright = u'2015, Christo' version = '0.1' # The short X.Y version. release = '0.1' # The full version, incl alpha/beta/rc. templates_path = ['_templates'] source_suffix = '.txt' # The suffix of source filenames. master_doc = 'index' # The master toctree document. today_fmt = '%Y-%m-%d' exclude_patterns = ['_build'] pygments_style = 'sphinx' keep_warnings = True # Keep warnings in output documents. # ------------------------------------------------------------------------- # Configure HTML output html_theme = 'sphinx_rtd_theme' html_show_sourcelink = True # Link to source from pages.
Add retrieval of docs version from VERSION.txt
# -*- coding: utf-8 -*- import sys import os from glob import glob # ------------------------------------------------------------------------- # Configure extensions extensions = [ 'sphinx.ext.autodoc', ] # ------------------------------------------------------------------------- # Helper function for retrieving info from files def read(*names): root_dir = os.path.dirname(__file__) path = os.path.join(root_dir, *names) with open(path) as f: return f.read() # ------------------------------------------------------------------------- # General configuration project = u'sphinxcontrib.traceables' copyright = u'2015, Christo' release = read('..', 'VERSION.txt') # The full version, incl alpha/beta/rc. version = '.'.join(release.split('.')[0:2]) # The short X.Y version. templates_path = ['_templates'] source_suffix = '.txt' # The suffix of source filenames. master_doc = 'index' # The master toctree document. today_fmt = '%Y-%m-%d' exclude_patterns = ['_build'] pygments_style = 'sphinx' keep_warnings = True # Keep warnings in output documents. # ------------------------------------------------------------------------- # Configure HTML output html_theme = 'sphinx_rtd_theme' html_show_sourcelink = True # Link to source from pages.
from fabric.api import env env.client = 'zsoobhan' env.project_code = 'prometheus' env.web_dir = 'www' # Environment-agnostic folders env.project_dir = '/var/www/%(client)s/%(project_code)s' % env env.static_dir = '/mnt/static/%(client)s/%(project_code)s' % env env.builds_dir = '%(project_dir)s/builds' % env def _configure(build_name): env.build = build_name env.virtualenv = '%(project_dir)s/virtualenvs/%(build)s/' % env env.data_dir = '%(project_dir)s/data/%(build)s/' % env env.nginx_conf = 'www/deploy/nginx/%(build)s.conf' % env env.supervisord_conf = 'www/deploy/supervisord/%(build)s.conf' % env env.wsgi = 'deploy/wsgi/%(build)s.wsgi' % env env.webserver_user = 'www-data' def prod(): _configure('prod') env.hosts = ['ec2-54-77-186-157.eu-west-1.compute.amazonaws.com'] env.remote_user = 'ubuntu' def test(): _configure('test') env.remote_user = 'ubuntu'
Switch to new ec2 instance
from fabric.api import env env.client = 'zsoobhan' env.project_code = 'prometheus' env.web_dir = 'www' # Environment-agnostic folders env.project_dir = '/var/www/%(client)s/%(project_code)s' % env env.static_dir = '/mnt/static/%(client)s/%(project_code)s' % env env.builds_dir = '%(project_dir)s/builds' % env def _configure(build_name): env.build = build_name env.virtualenv = '%(project_dir)s/virtualenvs/%(build)s/' % env env.data_dir = '%(project_dir)s/data/%(build)s/' % env env.nginx_conf = 'www/deploy/nginx/%(build)s.conf' % env env.supervisord_conf = 'www/deploy/supervisord/%(build)s.conf' % env env.wsgi = 'deploy/wsgi/%(build)s.wsgi' % env env.webserver_user = 'www-data' def prod(): _configure('prod') env.hosts = ['ec2-54-154-143-128.eu-west-1.compute.amazonaws.com'] env.remote_user = 'ubuntu' def test(): _configure('test') env.remote_user = 'ubuntu'
from __future__ import print_function from timeit import default_timer as timer import json import datetime print('Loading function') def eratosthenes(n): sieve = [ True for i in range(n+1) ] def markOff(pv): for i in range(pv+pv, n+1, pv): sieve[i] = False markOff(2) for i in range(3, n+1): if sieve[i]: markOff(i) return [ i for i in range(1, n+1) if sieve[i] ] def lambda_handler(event, context): start = timer() #print("Received event: " + json.dumps(event, indent=2)) maxPrime = int(event['queryStringParameters']['max']) numLoops = int(event['queryStringParameters']['loops']) print("looping " + str(numLoops) + " time(s)") for loop in range (0, numLoops): primes = eratosthenes(maxPrime) print("Highest 3 primes: " + str(primes.pop()) + ", " + str(primes.pop()) + ", " + str(primes.pop())) durationSeconds = timer() - start return {"statusCode": 200, \ "headers": {"Content-Type": "application/json"}, \ "body": "{\"durationSeconds\": " + str(durationSeconds) + \ ", \"max\": " + str(maxPrime) + ", \"loops\": " + str(numLoops) + "}"}
Convert tabs to spaces per PEP 8.
from __future__ import print_function from timeit import default_timer as timer import json import datetime print('Loading function') def eratosthenes(n): sieve = [ True for i in range(n+1) ] def markOff(pv): for i in range(pv+pv, n+1, pv): sieve[i] = False markOff(2) for i in range(3, n+1): if sieve[i]: markOff(i) return [ i for i in range(1, n+1) if sieve[i] ] def lambda_handler(event, context): start = timer() #print("Received event: " + json.dumps(event, indent=2)) maxPrime = int(event['queryStringParameters']['max']) numLoops = int(event['queryStringParameters']['loops']) print("looping " + str(numLoops) + " time(s)") for loop in range (0, numLoops): primes = eratosthenes(maxPrime) print("Highest 3 primes: " + str(primes.pop()) + ", " + str(primes.pop()) + ", " + str(primes.pop())) durationSeconds = timer() - start return {"statusCode": 200, \ "headers": {"Content-Type": "application/json"}, \ "body": "{\"durationSeconds\": " + str(durationSeconds) + \ ", \"max\": " + str(maxPrime) + ", \"loops\": " + str(numLoops) + "}"}
# -*- encoding: utf-8 -*- ############################################################################## # # Copyright (C) 2014-2015 Compassion CH (http://www.compassion.ch) # Releasing children from poverty in Jesus' name # @author: Emanuel Cino <[email protected]> # # The licence is in the file __openerp__.py # ############################################################################## from openerp.osv import orm from . import gp_connector class project_compassion(orm.Model): _inherit = 'compassion.project' def write(self, cr, uid, ids, vals, context=None): """Update Project in GP.""" res = super(project_compassion, self).write(cr, uid, ids, vals, context) gp_connect = gp_connector.GPConnect() for project in self.browse(cr, uid, ids, context): gp_connect.upsert_project(uid, project) return res
Fix bug in write project.
# -*- encoding: utf-8 -*- ############################################################################## # # Copyright (C) 2014-2015 Compassion CH (http://www.compassion.ch) # Releasing children from poverty in Jesus' name # @author: Emanuel Cino <[email protected]> # # The licence is in the file __openerp__.py # ############################################################################## from openerp.osv import orm from . import gp_connector class project_compassion(orm.Model): _inherit = 'compassion.project' def write(self, cr, uid, ids, vals, context=None): """Update Project in GP.""" res = super(project_compassion, self).write(cr, uid, ids, vals, context) if not isinstance(ids, list): ids = [ids] gp_connect = gp_connector.GPConnect() for project in self.browse(cr, uid, ids, context): gp_connect.upsert_project(uid, project) return res
import os import zipfile import tempfile from datapackage_pipelines.wrapper import ingest, spew import gobble params, datapackage, res_iter = ingest() spew(datapackage, res_iter) user = gobble.user.User() in_filename = open(params['in-file'], 'rb') in_file = zipfile.ZipFile(in_filename) temp_dir = tempfile.mkdtemp() for name in in_file.namelist(): in_file.extract(name, temp_dir) in_file.close() datapackage_json = os.path.join(temp_dir, 'datapackage.json') package = gobble.fiscal.FiscalDataPackage(datapackage_json, user=user) package.upload(skip_validation=True, publish=False)
Set the publication with a parameter.
import os import zipfile import tempfile from datapackage_pipelines.wrapper import ingest, spew import gobble params, datapackage, res_iter = ingest() spew(datapackage, res_iter) user = gobble.user.User() in_filename = open(params['in-file'], 'rb') in_file = zipfile.ZipFile(in_filename) temp_dir = tempfile.mkdtemp() for name in in_file.namelist(): in_file.extract(name, temp_dir) in_file.close() datapackage_json = os.path.join(temp_dir, 'datapackage.json') package = gobble.fiscal.FiscalDataPackage(datapackage_json, user=user) package.upload(skip_validation=True, publish=params.get('publish', False))
from flask import Blueprint, render_template, abort, request, redirect, session, url_for from flask.ext.login import current_user, login_user from sqlalchemy import desc from packages.objects import * from packages.common import * from packages.config import _cfg import os import zipfile import urllib api = Blueprint('api', __name__) @api.route("/test") @json_output def test(): return { 'value': 'Hello world!' }
Add API endpoint for logging in
from flask import Blueprint, render_template, abort, request, redirect, session, url_for from flask.ext.login import current_user, login_user from sqlalchemy import desc from packages.objects import * from packages.common import * from packages.config import _cfg import os import zipfile import urllib api = Blueprint('api', __name__) @api.route("/api/v1/login", methods=['POST']) @json_output def login(): username = request.form['username'] password = request.form['password'] user = User.query.filter(User.username.ilike(username)).first() if not user: return { 'success': False, 'error': 'Your username or password is incorrect.' } if user.confirmation != '' and user.confirmation != None: return { 'success': False, 'error': 'Your account is pending. Check your email or contact [email protected]' } if not bcrypt.checkpw(password, user.password): return { 'success': False, 'error': 'Your username or password is incorrect.' } login_user(user) return { 'success': True }
from functools import wraps import os from functools import wraps def restoring_chdir(fn): @wraps(fn) def decorator(*args, **kw): try: path = os.getcwd() return fn(*args, **kw) finally: os.chdir(path) return decorator class BaseBuilder(object): """ The Base for all Builders. Defines the API for subclasses. """ _changed = True @restoring_chdir def force(self, version): """ An optional step to force a build even when nothing has changed. """ print "Forcing a build by touching files" os.chdir(version.project.conf_dir(version.slug)) os.system('touch * && touch */*') def clean(self, version): """ Clean up the version so it's ready for usage. This is used to add RTD specific stuff to Sphinx, and to implement whitelists on projects as well. It is guaranteed to be called before your project is built. """ raise NotImplementedError def build(self, version): """ Do the actual building of the documentation. """ raise NotImplementedError def move(self, version): """ Move the documentation from it's generated place to its final home. This needs to understand both a single server dev environment, as well as a multi-server environment. """ raise NotImplementedError @property def changed(self): """ Says whether the documentation has changed, and requires further action. This is mainly used to short-circuit more expensive builds of other output formats if the project docs didn't change on an update. Defaults to `True` """ return self._changed
Kill _changed from the Base so subclassing makes more sense.
from functools import wraps import os from functools import wraps def restoring_chdir(fn): @wraps(fn) def decorator(*args, **kw): try: path = os.getcwd() return fn(*args, **kw) finally: os.chdir(path) return decorator class BaseBuilder(object): """ The Base for all Builders. Defines the API for subclasses. """ @restoring_chdir def force(self, version): """ An optional step to force a build even when nothing has changed. """ print "Forcing a build by touching files" os.chdir(version.project.conf_dir(version.slug)) os.system('touch * && touch */*') def clean(self, version): """ Clean up the version so it's ready for usage. This is used to add RTD specific stuff to Sphinx, and to implement whitelists on projects as well. It is guaranteed to be called before your project is built. """ raise NotImplementedError def build(self, version): """ Do the actual building of the documentation. """ raise NotImplementedError def move(self, version): """ Move the documentation from it's generated place to its final home. This needs to understand both a single server dev environment, as well as a multi-server environment. """ raise NotImplementedError @property def changed(self): """ Says whether the documentation has changed, and requires further action. This is mainly used to short-circuit more expensive builds of other output formats if the project docs didn't change on an update. Defaults to `True` """ return getattr(self, '_changed', True)
from sharepa.search import ShareSearch, basic_search # noqa from sharepa.analysis import bucket_to_dataframe, merge_dataframes # noqa def source_counts(): return bucket_to_dataframe( 'total_source_counts', basic_search.execute().aggregations.sourceAgg.buckets )
Make total_source_counts always be a full query
from sharepa.search import ShareSearch, basic_search # noqa from sharepa.analysis import bucket_to_dataframe, merge_dataframes # noqa def source_counts(): return bucket_to_dataframe( 'total_source_counts', ShareSearch().execute().aggregations.sourceAgg.buckets )
from collections import Counter class APMTracker(object): def handleInitGame(self, event, replay): for player in replay.players: player.apm = Counter() player.aps = Counter() player.seconds_played = replay.length.seconds def handlePlayerActionEvent(self, event, replay): event.player.aps[event.second] += 1 event.player.apm[event.second/60] += 1 def handlePlayerLeaveEvent(self, event, replay): event.player.seconds_played = event.second def handleEndGame(self, event, replay): print "Handling End Game" for player in replay.players: if len(player.apm.keys()) > 0: player.avg_apm = sum(player.apm.values())/float(player.seconds_played)*60 else: player.avg_apm = 0
Fix the engine's APM plugin and add some documentation.
from collections import Counter class APMTracker(object): """ Builds ``player.aps`` and ``player.apm`` dictionaries where an action is any Selection, Hotkey, or Ability event. Also provides ``player.avg_apm`` which is defined as the sum of all the above actions divided by the number of seconds played by the player (not necessarily the whole game) multiplied by 60. APM is 0 for games under 1 minute in length. """ def handleInitGame(self, event, replay): for player in replay.players: player.apm = Counter() player.aps = Counter() player.seconds_played = replay.length.seconds def handlePlayerActionEvent(self, event, replay): event.player.aps[event.second] += 1 event.player.apm[event.second/60] += 1 def handlePlayerLeaveEvent(self, event, replay): event.player.seconds_played = event.second def handleEndGame(self, event, replay): print "Handling End Game" for player in replay.players: if len(player.apm.keys()) > 0: player.avg_apm = sum(player.aps.values())/float(player.seconds_played)*60 else: player.avg_apm = 0
# Copyright 2012 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # # Copyright 2012 Nebula, 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 django.utils.translation import ugettext_lazy as _ import horizon class Instances(horizon.Panel): name = _("Instances") slug = 'instances' permissions = ('openstack.services.compute',) policy_rules = ((("compute", "context_is_admin"), ("compute", "compute:get_all")),)
Fix an incorrect policy rule in Admin > Instances Change-Id: I765ae0c36d19c88138fbea9545a2ca4791377ffb Closes-Bug: #1703066
# Copyright 2012 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # # Copyright 2012 Nebula, 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 django.utils.translation import ugettext_lazy as _ import horizon class Instances(horizon.Panel): name = _("Instances") slug = 'instances' permissions = ('openstack.services.compute',) policy_rules = ((("compute", "context_is_admin"), ("compute", "os_compute_api:servers:detail")),)
# -*- coding: utf-8 -*- # Generated by Django 1.11.5 on 2018-02-28 16:47 from __future__ import unicode_literals from django.db import migrations, models def instance_types_to_list(apps, schema_editor): PoolConfiguration = apps.get_model("ec2spotmanager", "PoolConfiguration") for pool in PoolConfiguration.objects.all(): pool.ec2_instance_types_list = [pool.ec2_instance_types] pool.save() class Migration(migrations.Migration): dependencies = [ ('ec2spotmanager', '0006_auto_20150625_2050'), ] operations = [ migrations.AlterField( model_name='poolconfiguration', name='ec2_instance_type', field=models.CharField(blank=True, max_length=1023, null=True), ), migrations.RenameField( model_name='poolconfiguration', old_name='ec2_instance_type', new_name='ec2_instance_types', ), migrations.RunPython(instance_types_to_list), ]
Fix migration. Custom triggers are not run in data migrations.
# -*- coding: utf-8 -*- # Generated by Django 1.11.5 on 2018-02-28 16:47 from __future__ import print_function, unicode_literals import json import sys from django.db import migrations, models def instance_type_to_list(apps, schema_editor): PoolConfiguration = apps.get_model("ec2spotmanager", "PoolConfiguration") for pool in PoolConfiguration.objects.all(): if pool.ec2_instance_type: pool.ec2_instance_type = json.dumps([pool.ec2_instance_type]) pool.save() def instance_type_from_list(apps, schema_editor): PoolConfiguration = apps.get_model("ec2spotmanager", "PoolConfiguration") for pool in PoolConfiguration.objects.all(): if pool.ec2_instance_types: types = json.loads(pool.ec2_instance_types) if len(types) > 1: print("pool %d had instance types %r, choosing %s for reverse migration" % (pool.id, types, types[0]), file=sys.stderr) pool.ec2_instance_types = types[0] pool.save() class Migration(migrations.Migration): dependencies = [ ('ec2spotmanager', '0006_auto_20150625_2050'), ] operations = [ migrations.AlterField( model_name='poolconfiguration', name='ec2_instance_type', field=models.CharField(blank=True, max_length=1023, null=True), ), migrations.RunPython( code=instance_type_to_list, reverse_code=instance_type_from_list, ), migrations.RenameField( model_name='poolconfiguration', old_name='ec2_instance_type', new_name='ec2_instance_types', ), ]
import re from django_webtest import WebTest class TestConstituencyDetailView(WebTest): def test_constituencies_page(self): # Just a smoke test to check that the page loads: response = self.app.get('/constituencies') aberdeen_north = response.html.find( 'a', text=re.compile(r'York Outer') ) self.assertTrue(aberdeen_north)
Make test_constituencies_page work without PopIt
import re from mock import patch from django_webtest import WebTest class TestConstituencyDetailView(WebTest): @patch('candidates.popit.PopIt') def test_constituencies_page(self, mock_popit): # Just a smoke test to check that the page loads: response = self.app.get('/constituencies') aberdeen_north = response.html.find( 'a', text=re.compile(r'York Outer') ) self.assertTrue(aberdeen_north)
# Copyright 2013 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """ActiveMaster definition.""" from config_bootstrap import Master class ChromiumFYI(Master.Master1): project_name = 'Chromium FYI' master_port = 8011 slave_port = 8111 master_port_alt = 8211 buildbot_url = 'http://build.chromium.org/p/chromium.fyi/' reboot_on_step_timeout = True pubsub_service_account_file = 'service-account-pubsub.json' pubsub_topic_url = 'projects/luci-milo/topics/public-buildbot' name = 'chromium.fyi'
Revert pubsub roll on FYI BUG= TBR=estaab Review URL: https://codereview.chromium.org/1688503002 git-svn-id: 239fca9b83025a0b6f823aeeca02ba5be3d9fd76@298680 0039d316-1c4b-4281-b951-d872f2087c98
# Copyright 2013 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """ActiveMaster definition.""" from config_bootstrap import Master class ChromiumFYI(Master.Master1): project_name = 'Chromium FYI' master_port = 8011 slave_port = 8111 master_port_alt = 8211 buildbot_url = 'http://build.chromium.org/p/chromium.fyi/' reboot_on_step_timeout = True
from django.db import models class Dependency(models.Model): source = models.CharField(max_length=255, db_index=True) depends_on = models.CharField(max_length=255, db_index=True) class Meta: unique_together = ("source", "depends_on")
Add __unicode__ to Dependency model
from __future__ import unicode_literals from django.db import models class Dependency(models.Model): source = models.CharField(max_length=255, db_index=True) depends_on = models.CharField(max_length=255, db_index=True) class Meta: unique_together = ("source", "depends_on") def __unicode__(self): return "{0} depends on {1}".format(self.source, self.depends_on)
#!/usr/bin/python # -*- coding: utf-8 -*- import sys import os sys.path.append(os.path.dirname(os.path.dirname(__file__)) + '/src') import DataVisualizing if len(sys.argv) != 2: print 'usage: create_heatmap.py <data file>' print ' expected infile is a datafile containing tracking data' print ' this is a csv file with the following columns:' print ' cartodb_id, date_time, day_of_year, distance_from_nest_in_meters' sys.exit(-1) def main(): dvis = DataVisualizing.TrackingVisualizer(infile=sys.argv[1]) print ('var day_month_heatdata = {0};'.format(dvis.as_heatmap_json(domain='month', agg_function='max'))) print ('var hour_month_heatdata = {0};'.format(dvis.as_heatmap_json(domain='month', subdomain='hour', agg_function='max'))) main()
Add raw line data to output
#!/usr/bin/python # -*- coding: utf-8 -*- import sys import os sys.path.append(os.path.dirname(os.path.dirname(__file__)) + '/src') import DataVisualizing if len(sys.argv) != 2: print 'usage: create_heatmap.py <data file>' print ' expected infile is a datafile containing tracking data' print ' this is a csv file with the following columns:' print ' cartodb_id, date_time, day_of_year, distance_from_nest_in_meters' sys.exit(-1) def main(): dvis = DataVisualizing.TrackingVisualizer(infile=sys.argv[1]) print ('var day_month_heatdata = {0};'.format(dvis.as_heatmap_json(domain='month', agg_function='max'))) print ('var hour_month_heatdata = {0};'.format(dvis.as_heatmap_json(domain='month', subdomain='hour', agg_function='max'))) print ('var hour_month_linedata = [ {{ \'key\': \'Maximum distance\', \'color\': \'green\', \'values\': {0} }} ];'.format(dvis.as_raw_line_json(agg_function='max'))) main()
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'tests.db', }, } INSTALLED_APPS = [ 'django.contrib.auth', 'django.contrib.admin', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.contenttypes', 'django.contrib.staticfiles', 'django_easyfilters', 'test_app', ] TEMPLATE_CONTEXT_PROCESSORS = [ "django.contrib.auth.context_processors.auth", "django.core.context_processors.debug", "django.core.context_processors.i18n", "django.core.context_processors.media", "django.core.context_processors.static", "django.core.context_processors.tz", "django.contrib.messages.context_processors.messages", "django.core.context_processors.request", ] ROOT_URLCONF = 'test_app.urls' DEBUG = True SITE_ID = 1 STATIC_URL = '/static/' SECRET_KEY = 'x'
Remove tz context processor (not available in 1.3)
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'tests.db', }, } INSTALLED_APPS = [ 'django.contrib.auth', 'django.contrib.admin', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.contenttypes', 'django.contrib.staticfiles', 'django_easyfilters', 'test_app', ] TEMPLATE_CONTEXT_PROCESSORS = [ "django.contrib.auth.context_processors.auth", "django.core.context_processors.debug", "django.core.context_processors.i18n", "django.core.context_processors.media", "django.core.context_processors.static", "django.contrib.messages.context_processors.messages", "django.core.context_processors.request", ] ROOT_URLCONF = 'test_app.urls' DEBUG = True SITE_ID = 1 STATIC_URL = '/static/' SECRET_KEY = 'x'
Add a small test for renderer
import mfr import json from tests import utils from tornado import testing class TestRenderHandler(utils.HandlerTestCase): @testing.gen_test def test_options_skips_prepare(self): # Would crash b/c lack of mocks yield self.http_client.fetch( self.get_url('/render'), method='OPTIONS' )
#!/usr/bin/env python def createBlankGrid(row,column): blankgrid = [[0 for x in range(column)] for y in range(row)] return blankgrid def getHeight(grid): return len(grid) def getWidth(grid): return len(grid[0]) def printGrid(grid): numRow = len(grid) for i in range(0,numRow): row = grid[i] rowstr = '' for j in row: rowstr += str(j)+' ' print(rowstr) def serializeGrid(grid): numRow = len(grid) numCol = len(grid[0]) gridstr = '' for j in range(0,numCol): for i in range(0,numRow): gridstr += str(grid[i][j]) return gridstr
Add setGrid and resetGrid functions
#!/usr/bin/env python def createBlankGrid(row,column): blankgrid = [[0 for x in range(column)] for y in range(row)] return blankgrid def getHeight(grid): return len(grid) def getWidth(grid): return len(grid[0]) def printGrid(grid): numRow = len(grid) for i in range(0,numRow): row = grid[i] rowstr = '' for j in row: rowstr += str(j)+' ' print(rowstr) def serializeGrid(grid): numRow = len(grid) numCol = len(grid[0]) gridstr = '' for j in range(0,numCol): for i in range(0,numRow): gridstr += str(grid[i][j]) return gridstr def setGrid(grid, setlist, rowoffset, coloffset): for entry in setlist: grid[entry[0]+rowoffset][entry[1]+coloffset] = 1 return grid def resetGrid(grid, setlist, rowoffset, coloffset): for entry in setlist: grid[entry[0]+rowoffset][entry[1]+coloffset] = 0 return grid
# from jaraco.util.itertools def always_iterable(item): """ Given an object, always return an iterable. If the item is not already iterable, return a tuple containing only the item. >>> always_iterable([1,2,3]) [1, 2, 3] >>> always_iterable('foo') ('foo',) >>> always_iterable(None) (None,) >>> always_iterable(xrange(10)) xrange(10) """ if isinstance(item, basestring) or not hasattr(item, '__iter__'): item = item, return item def total_seconds(td): """ Python 2.7 adds a total_seconds method to timedelta objects. See http://docs.python.org/library/datetime.html#datetime.timedelta.total_seconds >>> import datetime >>> total_seconds(datetime.timedelta(hours=24)) 86400.0 """ try: result = td.total_seconds() except AttributeError: seconds = td.seconds + td.days * 24 * 3600 result = (td.microseconds + seconds * 10**6) / 10**6 return result
Use float so test passes on Python 2.6
# from jaraco.util.itertools def always_iterable(item): """ Given an object, always return an iterable. If the item is not already iterable, return a tuple containing only the item. >>> always_iterable([1,2,3]) [1, 2, 3] >>> always_iterable('foo') ('foo',) >>> always_iterable(None) (None,) >>> always_iterable(xrange(10)) xrange(10) """ if isinstance(item, basestring) or not hasattr(item, '__iter__'): item = item, return item def total_seconds(td): """ Python 2.7 adds a total_seconds method to timedelta objects. See http://docs.python.org/library/datetime.html#datetime.timedelta.total_seconds >>> import datetime >>> total_seconds(datetime.timedelta(hours=24)) 86400.0 """ try: result = td.total_seconds() except AttributeError: seconds = td.seconds + td.days * 24 * 3600 result = float((td.microseconds + seconds * 10**6) / 10**6) return result
import sys from CITests import CITests # Libs in Application Examples appExamples = { #"KundurSMIB":"/ApplicationExamples/KundurSMIB/package.mo", #"TwoAreas":"/ApplicationExamples/TwoAreas/package.mo", #"SevenBus":"/ApplicationExamples/SevenBus/package.mo", #"IEEE9":"/ApplicationExamples/IEEE9/package.mo", #"IEEE14":"/ApplicationExamples/IEEE14/package.mo", #"AKD":"/ApplicationExamples/AKD/package.mo", #"N44":"/ApplicationExamples/N44/package.mo", #"OpenCPSD5d3B":"/ApplicationExamples/OpenCPSD5d3B/package.mo", #"RaPIdExperiments":"/ApplicationExamples/RaPIdExperiments/package.mo" } # Instance of CITests ci = CITests("/OpenIPSL") # Run Check on OpenIPSL passLib = ci.runSyntaxCheck("OpenIPSL","/OpenIPSL/package.mo") if not passLib: # Error in OpenIPSL sys.exit(1) else: # Run Check on App Examples passAppEx = 1 for package in appExamples.keys(): passAppEx = passAppEx * ci.runSyntaxCheck(package,appExamples[package]) # The tests are failing if the number of failed check > 0 if passAppEx: # Everything is fine sys.exit(0) else: # Exit with error sys.exit(1)
Fix the location path of OpenIPSL
import sys from CITests import CITests # Libs in Application Examples appExamples = { #"KundurSMIB":"/ApplicationExamples/KundurSMIB/package.mo", #"TwoAreas":"/ApplicationExamples/TwoAreas/package.mo", #"SevenBus":"/ApplicationExamples/SevenBus/package.mo", #"IEEE9":"/ApplicationExamples/IEEE9/package.mo", #"IEEE14":"/ApplicationExamples/IEEE14/package.mo", #"AKD":"/ApplicationExamples/AKD/package.mo", #"N44":"/ApplicationExamples/N44/package.mo", #"OpenCPSD5d3B":"/ApplicationExamples/OpenCPSD5d3B/package.mo", #"RaPIdExperiments":"/ApplicationExamples/RaPIdExperiments/package.mo" } # Instance of CITests ci = CITests("/OpenIPSL") # Run Check on OpenIPSL passLib = ci.runSyntaxCheck("OpenIPSL","/OpenIPSL/OpenIPSL/package.mo") if not passLib: # Error in OpenIPSL sys.exit(1) else: # Run Check on App Examples passAppEx = 1 for package in appExamples.keys(): passAppEx = passAppEx * ci.runSyntaxCheck(package,appExamples[package]) # The tests are failing if the number of failed check > 0 if passAppEx: # Everything is fine sys.exit(0) else: # Exit with error sys.exit(1)
Add sane log output formatter
############################################################################### # # Copyright (c) 2012 Ruslan Spivak # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # ############################################################################### __author__ = 'Ruslan Spivak <[email protected]>' import time import logging _DEFAULT_FMT = '%(levelname)-8s [%(asctime)s] %(name)s: %(message)s' class Formatter(logging.Formatter): def __init__(self, fmt=None, datefmt=None): super(Formatter, self).__init__(fmt or _DEFAULT_FMT, datefmt) # A user-configurable function to convert the creation time to a tuple. # It's used by Format.formatTime method and default is time.localtime() # We set it to convert time to a struct_time in UTC self.converter = time.gmtime def formatException(self, exc_info): text = super(Formatter, self).formatException(exc_info) # Prepend ! mark to every line text = '\n'.join(('! %s' % line) for line in text.splitlines()) return text
import unittest from src.dojo import Dojo class TestCreateRoom (unittest.TestCase): def test_create_room_successfully(self): my_class_instance = Dojo() initial_room_count = len(my_class_instance.all_rooms) blue_office = my_class_instance.create_room("office", "Blue") self.assertTrue(blue_office) new_room_count = len(my_class_instance.all_rooms) self.assertEqual(new_room_count - initial_room_count, 1) def test_create_rooms_successfully(self): my_class_instance = Dojo() initial_room_count = len(my_class_instance.all_rooms) offices = my_class_instance.create_room("office", "Blue", "Black", "Brown") self.assertTrue(offices) new_room_count = len(my_class_instance.all_rooms) self.assertEqual(new_room_count - initial_room_count, 3) def test_person_added_to_system(self): initial_person_count = len(self.dojo.all_people) person = self.dojo.add_person("Neil", "Armstrong", "Staff") self.assertTrue(person) new_person_count = len(self.dojo.all_people) self.assertEqual(new_person_count - initial_person_count, 1)
Add test to check that person has been given office
import unittest from src.dojo import Dojo class TestCreateRoom (unittest.TestCase): def test_create_room_successfully(self): my_class_instance = Dojo() initial_room_count = len(my_class_instance.all_rooms) blue_office = my_class_instance.create_room("office", "Blue") self.assertTrue(blue_office) new_room_count = len(my_class_instance.all_rooms) self.assertEqual(new_room_count - initial_room_count, 1) def test_create_rooms_successfully(self): my_class_instance = Dojo() initial_room_count = len(my_class_instance.all_rooms) offices = my_class_instance.create_room("office", "Blue", "Black", "Brown") self.assertTrue(offices) new_room_count = len(my_class_instance.all_rooms) self.assertEqual(new_room_count - initial_room_count, 3) def test_person_added_to_system(self): initial_person_count = len(self.dojo.all_people) person = self.dojo.add_person("Neil", "Armstrong", "Staff") self.assertTrue(person) new_person_count = len(self.dojo.all_people) self.assertEqual(new_person_count - initial_person_count, 1) def test_person_has_been_assigned_office(self): person = self.dojo.add_person("Neil", "Armstrong", "Staff") self.assertTrue(person) self.assertTrue(self.dojo.all_people[-1].has_office)
from . import platform_specific, input from .graphics import screen from .run_loop import main_run_loop, every platform_specific.fixup_env() def run(): main_run_loop.add_wait_callback(input.check_for_quit_event) main_run_loop.add_after_action_callback(screen.after_loop) main_run_loop.run()
Allow run argument to avoid @every template
from . import platform_specific, input from .graphics import screen from .run_loop import main_run_loop, every platform_specific.fixup_env() def run(loop=None): if loop is not None: every(seconds=1.0/30)(loop) main_run_loop.add_wait_callback(input.check_for_quit_event) main_run_loop.add_after_action_callback(screen.after_loop) main_run_loop.run()
import requests from flask import Flask, render_template app = Flask(__name__, instance_relative_config=True) app.config.from_pyfile("appconfig.py") BBC_id= "bbc-news" @app.route("/") def index(): r = requests.get( f"https://newsapi.org/v1/articles?source={BBC_id}&sortBy=top&apiKey={app.config['API_KEY']}" ) return render_template("index.html", articles=r.json().get("articles")) if __name__ == "__main__": app.run()
Create dynamic routing for supported sources.
import requests from flask import Flask, render_template app = Flask(__name__, instance_relative_config=True) app.config.from_pyfile("appconfig.py") sources = { "bbc": "bbc-news", "cnn": "cnn", "hackernews": "hacker-news" } def create_link(source): if source in sources.keys(): return f"https://newsapi.org/v1/articles?source={sources[source]}&sortBy=top&apiKey={app.config['API_KEY']}" @app.route("/") @app.route("/<source>") def index(source="bbc"): r = requests.get(create_link(source)) return render_template("index.html", articles=r.json().get("articles"), source=source) if __name__ == "__main__": app.run()
# -*- coding: utf-8 -*- __version__ = '$Id$' import family # The Wikia Search family # user-config.py: usernames['wikia']['wikia'] = 'User name' class Family(family.Family): def __init__(self): family.Family.__init__(self) self.name = u'wikia' self.langs = { u'wikia': None, } def hostname(self, code): return u'www.wikia.com' def version(self, code): return "1.15.1" def scriptpath(self, code): return '' def apipath(self, code): return '/api.php'
Update a version number from trunk r9016
# -*- coding: utf-8 -*- __version__ = '$Id$' import family # The Wikia Search family # user-config.py: usernames['wikia']['wikia'] = 'User name' class Family(family.Family): def __init__(self): family.Family.__init__(self) self.name = u'wikia' self.langs = { u'wikia': None, } def hostname(self, code): return u'www.wikia.com' def version(self, code): return "1.16.2" def scriptpath(self, code): return '' def apipath(self, code): return '/api.php'
#!/usr/bin/env python # -*- coding: utf-8 -*- '''Migration script for Search-enabled Models.''' from __future__ import absolute_import import logging from modularodm.query.querydialect import DefaultQueryDialect as Q from website.models import Node from framework.auth import User import website.search.search as search from website.app import init_app logger = logging.getLogger(__name__) app = init_app("website.settings", set_backends=True, routes=True) def migrate_nodes(): nodes = Node.find(Q('is_public', 'eq', True) & Q('is_deleted', 'eq', False)) for i, node in enumerate(nodes): node.update_search() return i + 1 # Started counting from 0 def migrate_users(): for i, user in enumerate(User.find()): if user.is_active: user.update_search() return i + 1 # Started counting from 0 def main(): ctx = app.test_request_context() ctx.push() search.delete_all() search.create_index() logger.info("Nodes migrated: {}".format(migrate_nodes())) logger.info("Users migrated: {}".format(migrate_users())) ctx.pop() if __name__ == '__main__': main()
Add additional logging for users'
#!/usr/bin/env python # -*- coding: utf-8 -*- '''Migration script for Search-enabled Models.''' from __future__ import absolute_import import logging from modularodm.query.querydialect import DefaultQueryDialect as Q from website.models import Node from framework.auth import User import website.search.search as search from website.app import init_app logger = logging.getLogger(__name__) app = init_app("website.settings", set_backends=True, routes=True) def migrate_nodes(): nodes = Node.find(Q('is_public', 'eq', True) & Q('is_deleted', 'eq', False)) for i, node in enumerate(nodes): node.update_search() logger.info('Nodes migrated: {}'.format(i + 1)) def migrate_users(): n_iter = 0 for i, user in enumerate(User.find()): if user.is_active: user.update_search() n_iter += 1 logger.info('Users iterated: {0}\nUsers migrated: {1}'.format(i + 1, n_iter)) def main(): ctx = app.test_request_context() ctx.push() search.delete_all() search.create_index() migrate_nodes() migrate_users() ctx.pop() if __name__ == '__main__': main()
from django.conf.urls import url, include from rest_framework import routers from api import views router = routers.DefaultRouter() router.register(r'categories', views.CategoryViewSet) router.register(r'commodities', views.CommodityViewSet) router.register(r'economies', views.EconomyViewSet) router.register(r'factions', views.FactionViewSet) router.register(r'governments', views.GovernmentViewSet) router.register(r'allegiances', views.AllegianceViewSet) router.register(r'states', views.StateViewSet) router.register(r'securities', views.SecurityViewSet) router.register(r'systems', views.SystemViewSet) router.register(r'station_types', views.StationTypeViewSet) router.register(r'stations', views.StationViewSet) router.register(r'listings', views.ListingViewSet) # Wire up our API using automatic URL routing. # Additionally, we include login URLs for the browsable API. urlpatterns = [ url(r'^/', include(router.urls)), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')) ]
Fix for the api at root url.
from django.conf.urls import url, include from rest_framework import routers from api import views router = routers.DefaultRouter() router.register(r'categories', views.CategoryViewSet) router.register(r'commodities', views.CommodityViewSet) router.register(r'economies', views.EconomyViewSet) router.register(r'factions', views.FactionViewSet) router.register(r'governments', views.GovernmentViewSet) router.register(r'allegiances', views.AllegianceViewSet) router.register(r'states', views.StateViewSet) router.register(r'securities', views.SecurityViewSet) router.register(r'systems', views.SystemViewSet) router.register(r'station_types', views.StationTypeViewSet) router.register(r'stations', views.StationViewSet) router.register(r'listings', views.ListingViewSet) # Wire up our API using automatic URL routing. # Additionally, we include login URLs for the browsable API. urlpatterns = [ url(r'^', include(router.urls)), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')) ]
#!/usr/bin/env python3 # coding=utf-8 import argparse import json import jsonschema import awp.packager import awp.validator # Parse arguments given via command-line interface def parse_cli_args(): parser = argparse.ArgumentParser() parser.add_argument( '--force', '-f', action='store_true', help='forces the copying of all files and directories') parser.add_argument( '--export', '-e', nargs='?', const='', default=None, help='exports the installed workflow to the local project directory') parser.add_argument( '--version', '-v', help='the new version number to use for the workflow') return parser.parse_args() # Locate and parse the configuration for the utility def get_utility_config(): with open('packager.json', 'r') as config_file: return json.load(config_file) def main(): cli_args = parse_cli_args() config = get_utility_config() try: awp.validator.validate_config(config) awp.packager.package_workflow( config, version=cli_args.version, export_file=cli_args.export, force=cli_args.force) except jsonschema.exceptions.ValidationError as error: print(error.message) if __name__ == '__main__': main()
Clarify where packager.json validation error originates
#!/usr/bin/env python3 # coding=utf-8 import argparse import json import jsonschema import awp.packager import awp.validator # Parse arguments given via command-line interface def parse_cli_args(): parser = argparse.ArgumentParser() parser.add_argument( '--force', '-f', action='store_true', help='forces the copying of all files and directories') parser.add_argument( '--export', '-e', nargs='?', const='', default=None, help='exports the installed workflow to the local project directory') parser.add_argument( '--version', '-v', help='the new version number to use for the workflow') return parser.parse_args() # Locate and parse the configuration for the utility def get_utility_config(): with open('packager.json', 'r') as config_file: return json.load(config_file) def main(): cli_args = parse_cli_args() config = get_utility_config() try: awp.validator.validate_config(config) awp.packager.package_workflow( config, version=cli_args.version, export_file=cli_args.export, force=cli_args.force) except jsonschema.exceptions.ValidationError as error: print('awp (from packager.json): {}'.format(error.message)) if __name__ == '__main__': main()
def YilmIndexVector(i, l, m): """ Compute the index of an 1D array of spherical harmonic coefficients corresponding to i, l, and m. Usage ----- index = YilmIndexVector (i, l, m) Returns ------- index : integer Index of an 1D array of spherical harmonic coefficients corresponding to i, l, and m. Parameters ---------- i : integer 1 corresponds to the cosine coefficient cilm[0,:,:], and 2 corresponds to the sine coefficient cilm[1,:,:]. l : integer The spherical harmonic degree. m : integer The angular order. Notes ----- YilmIndexVector will calculate the index of a 1D vector of spherical harmonic coefficients corresponding to degree l, angular order m and i (1 = cosine, 2 = sine). The index is given by l**2+(i-1)*l+m. """ return l**2 + (i - 1) * l + m
Add error checks to YilmIndexVector (and update docs)
def YilmIndexVector(i, l, m): """ Compute the index of a 1D array of spherical harmonic coefficients corresponding to i, l, and m. Usage ----- index = YilmIndexVector (i, l, m) Returns ------- index : integer Index of a 1D array of spherical harmonic coefficients corresponding to i, l, and m. Parameters ---------- i : integer 1 corresponds to the cosine coefficient Ylm = cilm[0,:,:], and 2 corresponds to the sine coefficient Yl,-m = cilm[1,:,:]. l : integer The spherical harmonic degree. m : integer The angular order, which must be greater or equal to zero. Notes ----- YilmIndexVector will calculate the index of a 1D vector of spherical harmonic coefficients corresponding to degree l, (positive) angular order m and i (1 = cosine, 2 = sine). The index is given by l**2+(i-1)*l+m. """ if l < 0: raise ValueError('The spherical harmonic degree must be positive. ' 'Input value is {:s}'.format(repr(l))) if m < 0: raise ValueError('The angular order must be positive. ' 'Input value is {:s}'.format(repr(m))) if m >= l: raise ValueError('The angular order must be less than or equal to ' 'the spherical harmonic degree. Input degree is {:s}.' ' Input order is {:s}.'.format(repr(l), repr(m))) return l**2 + (i - 1) * l + m
""" Harvester of pubmed for the SHARE notification service """ from __future__ import unicode_literals from scrapi.base import schemas from scrapi.base import helpers from scrapi.base import OAIHarvester def oai_extract_url_pubmed(identifiers): identifiers = [identifiers] if not isinstance(identifiers, list) else identifiers for item in identifiers: try: found_url = helpers.URL_REGEX.search(item).group() if 'viewcontent' not in found_url and '/pubmed/' in found_url: return found_url.decode('utf-8') except AttributeError: continue class PubMedHarvester(OAIHarvester): short_name = 'pubmedcentral' long_name = 'PubMed Central' url = 'http://www.ncbi.nlm.nih.gov/pmc/' schema = helpers.updated_schema( schemas.OAISCHEMA, { "uris": { "canonicalUri": ('//dc:identifier/node()', oai_extract_url_pubmed) } } ) base_url = 'http://www.pubmedcentral.nih.gov/oai/oai.cgi' property_list = [ 'type', 'source', 'publisher', 'rights', 'format', 'setSpec', 'date', 'identifier' ]
Add API call to top docstring
""" Harvester of PubMed Central for the SHARE notification service Example API call: http://www.pubmedcentral.nih.gov/oai/oai.cgi?verb=ListRecords&metadataPrefix=oai_dc&from=2015-04-13&until=2015-04-14 """ from __future__ import unicode_literals from scrapi.base import schemas from scrapi.base import helpers from scrapi.base import OAIHarvester def oai_extract_url_pubmed(identifiers): identifiers = [identifiers] if not isinstance(identifiers, list) else identifiers for item in identifiers: try: found_url = helpers.URL_REGEX.search(item).group() if 'viewcontent' not in found_url and '/pubmed/' in found_url: return found_url.decode('utf-8') except AttributeError: continue class PubMedHarvester(OAIHarvester): short_name = 'pubmedcentral' long_name = 'PubMed Central' url = 'http://www.ncbi.nlm.nih.gov/pmc/' schema = helpers.updated_schema( schemas.OAISCHEMA, { "uris": { "canonicalUri": ('//dc:identifier/node()', oai_extract_url_pubmed) } } ) base_url = 'http://www.pubmedcentral.nih.gov/oai/oai.cgi' property_list = [ 'type', 'source', 'publisher', 'rights', 'format', 'setSpec', 'date', 'identifier' ]
from .KEYNOTFOUND import KEYNOTFOUNDIN1 from .dict_diff import dict_diff def get_old_dict_values(old, new): # Returns the "old" value for two dicts. diff = dict_diff(old, new) return {key: diff[key][0] if diff[key][0] != KEYNOTFOUNDIN1 else None for key in diff}
Expand an object comprehension onto several lines
from .KEYNOTFOUND import KEYNOTFOUNDIN1 from .dict_diff import dict_diff def get_old_dict_values(old, new): # Returns the "old" value for two dicts. diff = dict_diff(old, new) return {key: diff[key][0] if diff[key][0] != KEYNOTFOUNDIN1 else None for key in diff}
import logging import time class PeriodicFilter: """ Periodic Filter to help keep down clutter in the console. Simply add this filter to your logger and the logger will only print periodically. The logger will always print logging levels of WARNING or higher """ def __init__(self, period, bypassLevel=logging.WARN): ''' :param period: Wait period (in seconds) between logs :param bypassLevel: Lowest logging level that the filter should ignore ''' self._period = period self._loggingLoop = True self._last_log = -period self._bypassLevel = bypassLevel def filter(self, record): """Performs filtering action for logger""" self._refresh_logger() return self._loggingLoop or record.levelno >= self._bypassLevel def _refresh_logger(self): """Determine if the log wait period has passed""" now = time.monotonic() self._loggingLoop = False if now - self._last_log > self._period: self._loggingLoop = True self._last_log = now
Create example usage. Rename bypass_level
import logging import time class PeriodicFilter: """ Periodic Filter to help keep down clutter in the console. Simply add this filter to your logger and the logger will only print periodically. The logger will always print logging levels of WARNING or higher, unless given a different bypass level Example class Component1: def setup(self): # Set period to 3 seconds, set bypass_level to WARN self.logger.addFilter(PeriodicFilter(3, bypass_level=logging.WARN)) def execute(self): # This message will be printed once every three seconds self.logger.info('Component1 Executing') # This message will be printed out every loop self.logger.warn('Uh oh, this shouldn't have happened...') """ def __init__(self, period, bypass_level=logging.WARN): ''' :param period: Wait period (in seconds) between logs :param bypass_level: Lowest logging level that the filter should ignore ''' self._period = period self._loggingLoop = True self._last_log = -period self._bypass_level = bypass_level def filter(self, record): """Performs filtering action for logger""" self._refresh_logger() return self._loggingLoop or record.levelno >= self._bypass_level def _refresh_logger(self): """Determine if the log wait period has passed""" now = time.monotonic() self._loggingLoop = False if now - self._last_log > self._period: self._loggingLoop = True self._last_log = now
# Copyright (c) 2012-2020, Mark Peek <[email protected]> # All rights reserved. # # See LICENSE file for full license. # # *** Do not modify - this file is autogenerated *** # Resource specification version: 18.6.0 from . import AWSObject from troposphere import Tags class Assignment(AWSObject): resource_type = "AWS::SSO::Assignment" props = { 'InstanceArn': (basestring, True), 'PermissionSetArn': (basestring, True), 'PrincipalId': (basestring, True), 'PrincipalType': (basestring, True), 'TargetId': (basestring, True), 'TargetType': (basestring, True), } class PermissionSet(AWSObject): resource_type = "AWS::SSO::PermissionSet" props = { 'Description': (basestring, False), 'InlinePolicy': (basestring, False), 'InstanceArn': (basestring, True), 'ManagedPolicies': ([basestring], False), 'Name': (basestring, True), 'RelayStateType': (basestring, False), 'SessionDuration': (basestring, False), 'Tags': (Tags, False), }
Update SSO per 2020-12-18 changes
# Copyright (c) 2012-2021, Mark Peek <[email protected]> # All rights reserved. # # See LICENSE file for full license. # # *** Do not modify - this file is autogenerated *** # Resource specification version: 25.0.0 from . import AWSObject from . import AWSProperty from troposphere import Tags class Assignment(AWSObject): resource_type = "AWS::SSO::Assignment" props = { 'InstanceArn': (basestring, True), 'PermissionSetArn': (basestring, True), 'PrincipalId': (basestring, True), 'PrincipalType': (basestring, True), 'TargetId': (basestring, True), 'TargetType': (basestring, True), } class AccessControlAttributeValueSourceList(AWSProperty): props = { 'AccessControlAttributeValueSourceList': ([basestring], False), } class AccessControlAttributeValue(AWSProperty): props = { 'Source': (AccessControlAttributeValueSourceList, True), } class AccessControlAttribute(AWSProperty): props = { 'Key': (basestring, True), 'Value': (AccessControlAttributeValue, True), } class InstanceAccessControlAttributeConfiguration(AWSObject): resource_type = "AWS::SSO::InstanceAccessControlAttributeConfiguration" props = { 'AccessControlAttributes': ([AccessControlAttribute], False), 'InstanceAccessControlAttributeConfiguration': (dict, False), 'InstanceArn': (basestring, True), } class PermissionSet(AWSObject): resource_type = "AWS::SSO::PermissionSet" props = { 'Description': (basestring, False), 'InlinePolicy': (dict, False), 'InstanceArn': (basestring, True), 'ManagedPolicies': ([basestring], False), 'Name': (basestring, True), 'RelayStateType': (basestring, False), 'SessionDuration': (basestring, False), 'Tags': (Tags, False), }
# third party from sqlalchemy import Boolean from sqlalchemy import Column from sqlalchemy import ForeignKey from sqlalchemy import Integer from sqlalchemy import String # relative from . import Base class NodeRoute(Base): __tablename__ = "node_route" id = Column(Integer(), primary_key=True, autoincrement=True) node_id = Column(Integer, ForeignKey("node.id")) host_or_ip = Column(String(255)) is_vpn = Column(Boolean(), default=False)
ADD vpn_endpoint and vpn_key columns
# third party from sqlalchemy import Boolean from sqlalchemy import Column from sqlalchemy import ForeignKey from sqlalchemy import Integer from sqlalchemy import String # relative from . import Base class NodeRoute(Base): __tablename__ = "node_route" id = Column(Integer(), primary_key=True, autoincrement=True) node_id = Column(Integer, ForeignKey("node.id")) host_or_ip = Column(String(255), default="") is_vpn = Column(Boolean(), default=False) vpn_endpoint = Column(String(255), default="") vpn_key = Column(String(255), default="")
from setuptools import setup, find_packages setup( name='acc_provision', version='1.9.6', description='Tool to provision ACI for ACI Containers Controller', author="Cisco Systems, Inc.", author_email="[email protected]", url='http://github.com/noironetworks/aci-containers/', license="http://www.apache.org/licenses/LICENSE-2.0", packages=find_packages(), include_package_data=True, zip_safe=False, entry_points={ 'console_scripts': [ 'acc-provision=acc_provision.acc_provision:main', ] }, install_requires=[ 'requests', 'pyyaml', 'jinja2', 'pyopenssl', ], )
Update acc-provision version to 1.9.7
from setuptools import setup, find_packages setup( name='acc_provision', version='1.9.7', description='Tool to provision ACI for ACI Containers Controller', author="Cisco Systems, Inc.", author_email="[email protected]", url='http://github.com/noironetworks/aci-containers/', license="http://www.apache.org/licenses/LICENSE-2.0", packages=find_packages(), include_package_data=True, zip_safe=False, entry_points={ 'console_scripts': [ 'acc-provision=acc_provision.acc_provision:main', ] }, install_requires=[ 'requests', 'pyyaml', 'jinja2', 'pyopenssl', ], )
from django.contrib.auth.models import User def user_new_str(self): return self.username if self.get_full_name() == "" else self.get_full_name() # Replace the __str__ method in the User class with our new implementation User.__str__ = user_new_str
Change titles for the site
from django.contrib import admin from django.contrib.auth.models import User def user_new_str(self): return self.username if self.get_full_name() == "" else self.get_full_name() # Replace the __str__ method in the User class with our new implementation User.__str__ = user_new_str admin.site.site_header = 'SENKUMBA' admin.site.site_title = 'SENKUMBA' admin.site.index_title = 'SENKUMBA'
import sublime, sublime_plugin, webbrowser QD_URL = "http://localhost:5000/" class GoToQuantifiedDevDashboardCommand(sublime_plugin.TextCommand): def run(self,edit): SETTINGS = {} SETTINGS_FILE = "QuantifiedDev.sublime-settings" SETTINGS = sublime.load_settings(SETTINGS_FILE) stream_id = SETTINGS.get("streamId") read_token = SETTINGS.get("readToken") qd_url = QD_URL url = "%(qd_url)sdashboard?streamId=%(stream_id)s&readToken=%(read_token)s" % locals() webbrowser.open_new_tab(url)
Fix url to be consistent.
import sublime, sublime_plugin, webbrowser QD_URL = "http://localhost:5000" class GoToQuantifiedDevDashboardCommand(sublime_plugin.TextCommand): def run(self,edit): SETTINGS = {} SETTINGS_FILE = "QuantifiedDev.sublime-settings" SETTINGS = sublime.load_settings(SETTINGS_FILE) stream_id = SETTINGS.get("streamId") read_token = SETTINGS.get("readToken") qd_url = QD_URL url = "%(qd_url)s/dashboard?streamId=%(stream_id)s&readToken=%(read_token)s" % locals() webbrowser.open_new_tab(url)
from django.conf import settings class XmlJsonImportModuleException(Exception): pass
Throw exception for not existing XSLT_FILES_DIR setting
from django.conf import settings class XmlJsonImportModuleException(Exception): pass if not hasattr(settings, 'XSLT_FILES_DIR'): raise XmlJsonImportModuleException('Settings must contain XSLT_FILES_DIR parameter')
from django.conf.urls import url from api.logs import views urlpatterns = [ url(r'^(?P<log_id>\w+)/$', views.NodeLogDetail.as_view(), name=views.NodeLogDetail.view_name), url(r'^(?P<log_id>\w+)/nodes/$', views.LogNodeList.as_view(), name=views.LogNodeList.view_name), ]
Add /v2/logs/log_id/added_contributors/ to list of URL's.
from django.conf.urls import url from api.logs import views urlpatterns = [ url(r'^(?P<log_id>\w+)/$', views.NodeLogDetail.as_view(), name=views.NodeLogDetail.view_name), url(r'^(?P<log_id>\w+)/nodes/$', views.LogNodeList.as_view(), name=views.LogNodeList.view_name), url(r'^(?P<log_id>\w+)/added_contributors/$', views.NodeLogAddedContributors.as_view(), name=views.NodeLogAddedContributors.view_name), ]
from setuptools import setup, find_packages from os import path here = path.abspath(path.dirname(__file__)) description = 'The official Python3 Domo API SDK - Domo, Inc.' long_description = 'See https://github.com/domoinc/domo-python-sdk for more details.' setup( name='pydomo', version='0.3.0.01', description=description, long_description=long_description, author='Jeremy Morris', author_email='[email protected]', url='https://github.com/domoinc/domo-python-sdk', download_url='https://github.com/domoinc/domo-python-sdk/tarball/0.2.2.1', keywords='domo api sdk', license='MIT', packages=find_packages(exclude=['examples']), install_requires=[ 'requests', 'requests_toolbelt', ], python_requires='>=3', )
Update to prep for v0.3.0.2
from setuptools import setup, find_packages from os import path here = path.abspath(path.dirname(__file__)) description = 'The official Python3 Domo API SDK - Domo, Inc.' long_description = 'See https://github.com/domoinc/domo-python-sdk for more details.' setup( name='pydomo', version='0.3.0.2', description=description, long_description=long_description, author='Jeremy Morris', author_email='[email protected]', url='https://github.com/domoinc/domo-python-sdk', download_url='https://github.com/domoinc/domo-python-sdk/tarball/0.2.2.1', keywords='domo api sdk', license='MIT', packages=find_packages(exclude=['examples']), install_requires=[ 'requests', 'requests_toolbelt', ], python_requires='>=3', )
#!/usr/bin/env python from flask import Flask, abort, make_response from socket import inet_aton, error as socket_error from .db import Database app = Flask(__name__) db = Database() @app.route('/ip/<ip>') def lookup(ip): try: k = inet_aton(ip) except socket_error: abort(400) info_as_json = db.lookup(k) if info_as_json is None: abort(404) response = make_response(info_as_json) response.headers['Content-type'] = 'application/json' return response if __name__ == '__main__': import argparse import sys parser = argparse.ArgumentParser() parser.add_argument('--host', default='localhost') parser.add_argument('--port', default=5555, type=int) parser.add_argument('--debug', default=False, action='store_true') args = parser.parse_args() try: app.run(**vars(args)) except KeyboardInterrupt: sys.stderr.write("Aborting...\n")
Use WHIP_SETTINGS environment var for Flask app
#!/usr/bin/env python from flask import Flask, abort, make_response from socket import inet_aton, error as socket_error from .db import Database app = Flask(__name__) app.config.from_envvar('WHIP_SETTINGS') db = Database(app.config['DATABASE_DIR']) @app.route('/ip/<ip>') def lookup(ip): try: k = inet_aton(ip) except socket_error: abort(400) info_as_json = db.lookup(k) if info_as_json is None: abort(404) response = make_response(info_as_json) response.headers['Content-type'] = 'application/json' return response if __name__ == '__main__': import argparse import sys parser = argparse.ArgumentParser() parser.add_argument('--host', default='localhost') parser.add_argument('--port', default=5555, type=int) parser.add_argument('--debug', default=False, action='store_true') args = parser.parse_args() try: app.run(**vars(args)) except KeyboardInterrupt: sys.stderr.write("Aborting...\n")
from setuptools import setup setup( name='syslog2IRC', version='0.8', description='A proxy to forward syslog messages to IRC', url='http://homework.nwsnet.de/releases/c474/#syslog2irc', author='Jochen Kupperschmidt', author_email='[email protected]', license='MIT', classifiers=[ 'Environment :: Console', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Topic :: Communications :: Chat :: Internet Relay Chat', 'Topic :: Internet', 'Topic :: System :: Logging', 'Topic :: System :: Monitoring', 'Topic :: System :: Networking :: Monitoring', 'Topic :: System :: Systems Administration', ], )
Include README content as long description.
# -*- coding: utf-8 -*- import codecs from setuptools import setup with codecs.open('README.rst', encoding='utf-8') as f: long_description = f.read() setup( name='syslog2IRC', version='0.8', description='A proxy to forward syslog messages to IRC', long_description=long_description, url='http://homework.nwsnet.de/releases/c474/#syslog2irc', author='Jochen Kupperschmidt', author_email='[email protected]', license='MIT', classifiers=[ 'Environment :: Console', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Topic :: Communications :: Chat :: Internet Relay Chat', 'Topic :: Internet', 'Topic :: System :: Logging', 'Topic :: System :: Monitoring', 'Topic :: System :: Networking :: Monitoring', 'Topic :: System :: Systems Administration', ], )
#!/usr/bin/env python from setuptools import setup execfile('kronos/version.py') setup( name = 'django-kronos', version = __version__, description = 'Kronos is a Django application that makes it easy to define and schedule tasks with cron.', long_description = open('README.rst').read(), author = 'Johannes Gorset', author_email = '[email protected]', url = 'http://github.com/jgorset/kronos', packages = ['kronos', 'kronos.management', 'kronos.management.commands'] )
Add history to long description
#!/usr/bin/env python from setuptools import setup execfile('kronos/version.py') readme = open('README.rst').read() history = open('HISTORY.rst').read() setup( name = 'django-kronos', version = __version__, description = 'Kronos is a Django application that makes it easy to define and schedule tasks with cron.', long_description = readme + '\n\n' + history, author = 'Johannes Gorset', author_email = '[email protected]', url = 'http://github.com/jgorset/kronos', packages = ['kronos', 'kronos.management', 'kronos.management.commands'] )
__author__ = 'katharine' import sys from setuptools import setup, find_packages requires = [ 'libpebble2==0.0.14', 'httplib2==0.9.1', 'oauth2client==1.4.12', 'progressbar2==2.7.3', 'pyasn1==0.1.8', 'pyasn1-modules==0.0.6', 'pypng==0.0.17', 'pyqrcode==1.1', 'requests==2.7.0', 'rsa==3.1.4', 'pyserial==2.7', 'six==1.9.0', 'websocket-client==0.32.0', 'wheel==0.24.0', 'colorama==0.3.3', ] if sys.version_info < (3, 4, 0): requires.append('enum34==1.0.4') setup(name='pebble-tool', version='3.6', description='Tool for interacting with pebbles.', url='https://github.com/pebble/pebble-tool', author='Pebble Technology Corporation', author_email='[email protected]', license='MIT', packages=find_packages(), install_requires=requires, entry_points={ 'console_scripts': ['pebble=pebble_tool:run_tool'], }, zip_safe=True)
Make sure our python alias is included in packaged versions.
__author__ = 'katharine' import sys from setuptools import setup, find_packages requires = [ 'libpebble2==0.0.14', 'httplib2==0.9.1', 'oauth2client==1.4.12', 'progressbar2==2.7.3', 'pyasn1==0.1.8', 'pyasn1-modules==0.0.6', 'pypng==0.0.17', 'pyqrcode==1.1', 'requests==2.7.0', 'rsa==3.1.4', 'pyserial==2.7', 'six==1.9.0', 'websocket-client==0.32.0', 'wheel==0.24.0', 'colorama==0.3.3', ] if sys.version_info < (3, 4, 0): requires.append('enum34==1.0.4') setup(name='pebble-tool', version='3.6', description='Tool for interacting with pebbles.', url='https://github.com/pebble/pebble-tool', author='Pebble Technology Corporation', author_email='[email protected]', license='MIT', packages=find_packages(), package_data={ 'pebble_tool.commands.sdk': ['python'], }, install_requires=requires, entry_points={ 'console_scripts': ['pebble=pebble_tool:run_tool'], }, zip_safe=False)
# Python imports from setuptools import setup # Project imports from notable import app # Attributes AUTHOR = 'John McFarlane' DESCRIPTION = 'A very simple note taking application' EMAIL = '[email protected]' NAME = 'Notable' PYPI = 'http://pypi.python.org/packages/source/N/Notable' URL = 'https://github.com/jmcfarlane/Notable' CLASSIFIERS = """ Development Status :: 2 - Pre-Alpha Intended Audience :: Developers License :: OSI Approved :: MIT License Operating System :: OS Independent Programming Language :: Python Topic :: Internet :: WWW/HTTP Intended Audience :: End Users/Desktop Topic :: Office/Business :: News/Diary Topic :: Security :: Cryptography Topic :: Utilities """ setup( author = AUTHOR, author_email = EMAIL, classifiers = [c for c in CLASSIFIERS.split('\n') if c], description = DESCRIPTION, download_url = '%s/Notable-%s.tar.gz' % (PYPI, app.version), include_package_data = True, name = NAME, packages = ['notable'], scripts = ['scripts/notable'], url = URL, version = app.version )
Set nose.collector as the test_suite
# Python imports from setuptools import setup # Project imports from notable import app # Attributes AUTHOR = 'John McFarlane' DESCRIPTION = 'A very simple note taking application' EMAIL = '[email protected]' NAME = 'Notable' PYPI = 'http://pypi.python.org/packages/source/N/Notable' URL = 'https://github.com/jmcfarlane/Notable' CLASSIFIERS = """ Development Status :: 2 - Pre-Alpha Intended Audience :: Developers License :: OSI Approved :: MIT License Operating System :: OS Independent Programming Language :: Python Topic :: Internet :: WWW/HTTP Intended Audience :: End Users/Desktop Topic :: Office/Business :: News/Diary Topic :: Security :: Cryptography Topic :: Utilities """ setup( author = AUTHOR, author_email = EMAIL, classifiers = [c for c in CLASSIFIERS.split('\n') if c], description = DESCRIPTION, download_url = '%s/Notable-%s.tar.gz' % (PYPI, app.version), include_package_data = True, name = NAME, packages = ['notable'], scripts = ['scripts/notable'], test_suite='nose.collector', url = URL, version = app.version )
#!/usr/bin/env python # -*- coding: utf-8 -*- from setuptools import setup def version(): """Return version string.""" with open('autopep8.py') as input_file: for line in input_file: if line.startswith('__version__'): import ast return ast.literal_eval(line.split('=')[1].strip()) with open('README.rst') as readme: setup( name='autopep8', version=version(), description='A tool that automatically formats Python code to conform ' 'to the PEP 8 style guide', long_description=readme.read(), license='Expat License', author='Hideo Hattori', author_email='[email protected]', url='https://github.com/hhatto/autopep8', classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', 'Programming Language :: Unix Shell', ], keywords='automation, pep8, format', install_requires=['pep8'], test_suite='test.test_autopep8', py_modules=['autopep8'], zip_safe=False, entry_points={'console_scripts': ['autopep8 = autopep8:main']}, )
Make pep8 dependency more explicit
#!/usr/bin/env python # -*- coding: utf-8 -*- from setuptools import setup def version(): """Return version string.""" with open('autopep8.py') as input_file: for line in input_file: if line.startswith('__version__'): import ast return ast.literal_eval(line.split('=')[1].strip()) with open('README.rst') as readme: setup( name='autopep8', version=version(), description='A tool that automatically formats Python code to conform ' 'to the PEP 8 style guide', long_description=readme.read(), license='Expat License', author='Hideo Hattori', author_email='[email protected]', url='https://github.com/hhatto/autopep8', classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', 'Programming Language :: Unix Shell', ], keywords='automation, pep8, format', install_requires=['pep8 >= 1.3'], test_suite='test.test_autopep8', py_modules=['autopep8'], zip_safe=False, entry_points={'console_scripts': ['autopep8 = autopep8:main']}, )
from better_zoom import BetterZoom from better_selecting_zoom import BetterSelectingZoom from broadcaster import BroadcasterTool from dataprinter import DataPrinter from data_label_tool import DataLabelTool from drag_zoom import DragZoom from enthought.enable.tools.drag_tool import DragTool from draw_points_tool import DrawPointsTool from highlight_tool import HighlightTool from image_inspector_tool import ImageInspectorTool, ImageInspectorOverlay from lasso_selection import LassoSelection from legend_tool import LegendTool from legend_highlighter import LegendHighlighter from line_inspector import LineInspector from line_segment_tool import LineSegmentTool from move_tool import MoveTool from pan_tool import PanTool from point_marker import PointMarker from range_selection import RangeSelection from range_selection_2d import RangeSelection2D from range_selection_overlay import RangeSelectionOverlay from regression_lasso import RegressionLasso, RegressionOverlay from save_tool import SaveTool from scatter_inspector import ScatterInspector from select_tool import SelectTool from simple_inspector import SimpleInspectorTool from tracking_pan_tool import TrackingPanTool from tracking_zoom import TrackingZoom from traits_tool import TraitsTool from zoom_tool import ZoomTool # EOF
[Chaco] Remove deprecated DragZoom from Chaco tools API to eliminate irrelevant BaseZoomTool deprecation warning. DragZoom is still used in 4 Chaco examples
from better_zoom import BetterZoom from better_selecting_zoom import BetterSelectingZoom from broadcaster import BroadcasterTool from dataprinter import DataPrinter from data_label_tool import DataLabelTool from enthought.enable.tools.drag_tool import DragTool from draw_points_tool import DrawPointsTool from highlight_tool import HighlightTool from image_inspector_tool import ImageInspectorTool, ImageInspectorOverlay from lasso_selection import LassoSelection from legend_tool import LegendTool from legend_highlighter import LegendHighlighter from line_inspector import LineInspector from line_segment_tool import LineSegmentTool from move_tool import MoveTool from pan_tool import PanTool from point_marker import PointMarker from range_selection import RangeSelection from range_selection_2d import RangeSelection2D from range_selection_overlay import RangeSelectionOverlay from regression_lasso import RegressionLasso, RegressionOverlay from save_tool import SaveTool from scatter_inspector import ScatterInspector from select_tool import SelectTool from simple_inspector import SimpleInspectorTool from tracking_pan_tool import TrackingPanTool from tracking_zoom import TrackingZoom from traits_tool import TraitsTool from zoom_tool import ZoomTool # EOF
# # Copyright (c) 2011 rPath, Inc. # # All Rights Reserved # BAD_REQUEST = 400 NOT_FOUND = 404 INTERNAL_SERVER_ERROR = 500 class RbuilderError(Exception): "An unknown error has occured." status = INTERNAL_SERVER_ERROR def __init__(self, **kwargs): cls = self.__class__ self.msg = cls.__doc__ self.kwargs = kwargs def __str__(self): try: return self.msg % self.kwargs except TypeError: return self.msg class CollectionPageNotFound(RbuilderError): "The requested page of the collection was not found." status = NOT_FOUND class UknownFilterOperator(RbuilderError): "%(filter)s is an invalid filter operator." status = BAD_REQUEST class InvalidFilterValue(RbuilderError): "%(value)s in an invalid value for filter operator %(filter)s" status = BAD_REQUEST
Fix typo in exception name
# # Copyright (c) 2011 rPath, Inc. # # All Rights Reserved # BAD_REQUEST = 400 NOT_FOUND = 404 INTERNAL_SERVER_ERROR = 500 class RbuilderError(Exception): "An unknown error has occured." status = INTERNAL_SERVER_ERROR def __init__(self, **kwargs): cls = self.__class__ self.msg = cls.__doc__ self.kwargs = kwargs def __str__(self): try: return self.msg % self.kwargs except TypeError: return self.msg class CollectionPageNotFound(RbuilderError): "The requested page of the collection was not found." status = NOT_FOUND class UnknownFilterOperator(RbuilderError): "%(filter)s is an invalid filter operator." status = BAD_REQUEST class InvalidFilterValue(RbuilderError): "%(value)s in an invalid value for filter operator %(filter)s" status = BAD_REQUEST
try: from functools import wraps except ImportError: from django.utils.functional import wraps from feincms.models import Page def add_page_to_extra_context(view_func): def inner(request, *args, **kwargs): kwargs.setdefault('extra_context', {}) kwargs['extra_context']['feincms_page'] = Page.objects.best_match_from_request(request) return view_func(request, *args, **kwargs) return wraps(view_func)(inner)
Fix page import path in view decorator module
try: from functools import wraps except ImportError: from django.utils.functional import wraps from feincms.module.page.models import Page def add_page_to_extra_context(view_func): def inner(request, *args, **kwargs): kwargs.setdefault('extra_context', {}) kwargs['extra_context']['feincms_page'] = Page.objects.best_match_from_request(request) return view_func(request, *args, **kwargs) return wraps(view_func)(inner)
from __future__ import absolute_import from __future__ import division from __future__ import print_function def make_set(): pass def link(): pass def find(): pass def union(): pass def kruskal(): """Kruskal's algorithm for minimum spanning tree in weighted graph. Time complexity for graph G(V, E): O(|E|+|V|+|E|log(|V|)) = O(|E|log(|V|^2)) = O(|E|log(|V|)). """ pass def main(): w_graph_d = { 'a': {'b': 1, 'd': 4, 'e': 3}, 'b': {'a': 1, 'd': 4, 'e': 2}, 'c': {'e': 4, 'f': 5}, 'd': {'a': 4, 'b': 4, 'e': 4}, 'e': {'a': 3, 'b': 2, 'c': 4, 'd': 4, 'f': 7}, 'f': {'c': 5, 'e': 7} } print('w_graph_d:\n{}'.format(w_graph_d)) print('Kruskal\'s minimum spanning tree:') pass if __name__ == '__main__': main()
Revise doc string by adding "undirected"
from __future__ import absolute_import from __future__ import division from __future__ import print_function def make_set(): pass def link(): pass def find(): pass def union(): pass def kruskal(): """Kruskal's algorithm for minimum spanning tree in weighted undirected graph. Time complexity for graph G(V, E): O(|E|+|V|+|E|log(|V|)) = O(|E|log(|V|^2)) = O(|E|log(|V|)). """ pass def main(): w_graph_d = { 'a': {'b': 1, 'd': 4, 'e': 3}, 'b': {'a': 1, 'd': 4, 'e': 2}, 'c': {'e': 4, 'f': 5}, 'd': {'a': 4, 'b': 4, 'e': 4}, 'e': {'a': 3, 'b': 2, 'c': 4, 'd': 4, 'f': 7}, 'f': {'c': 5, 'e': 7} } print('w_graph_d:\n{}'.format(w_graph_d)) print('Kruskal\'s minimum spanning tree:') pass if __name__ == '__main__': main()
import random import unittest from aioes.pool import RandomSelector, RoundRobinSelector class TestRandomSelector(unittest.TestCase): def setUp(self): random.seed(123456) def tearDown(self): random.seed(None) def test_select(self): s = RandomSelector() r = s.select([1, 2, 3]) self.assertEqual(2, r) class TestRoundRobinSelector(unittest.TestCase): def test_select(self): s = RoundRobinSelector() r = s.select([1, 2, 3]) self.assertEqual(2, r) r = s.select([1, 2, 3]) self.assertEqual(3, r) r = s.select([1, 2, 3]) self.assertEqual(1, r) r = s.select([1, 2, 3]) self.assertEqual(2, r)
Add more tests for pool
import asyncio import random import unittest from aioes.pool import RandomSelector, RoundRobinSelector, ConnectionPool from aioes.transport import Endpoint from aioes.connection import Connection class TestRandomSelector(unittest.TestCase): def setUp(self): random.seed(123456) def tearDown(self): random.seed(None) def test_select(self): s = RandomSelector() r = s.select([1, 2, 3]) self.assertEqual(2, r) class TestRoundRobinSelector(unittest.TestCase): def test_select(self): s = RoundRobinSelector() r = s.select([1, 2, 3]) self.assertEqual(2, r) r = s.select([1, 2, 3]) self.assertEqual(3, r) r = s.select([1, 2, 3]) self.assertEqual(1, r) r = s.select([1, 2, 3]) self.assertEqual(2, r) class TestConnectionPool(unittest.TestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): self.loop.close() def make_pool(self): conn = Connection(Endpoint('localhost', 9200), loop=self.loop) pool = ConnectionPool([conn], loop=self.loop) self.addCleanup(pool.close) return pool def test_ctor(self): pool = self.make_pool() self.assertAlmostEqual(60, pool.dead_timeout) self.assertAlmostEqual(5, pool.timeout_cutoff)
#import spam import filter_lta #VALID_FILES = filter_lta.VALID_OBS().split('\n') print filter_lta.VALID_OBS() #def extract_basename(): def main(): #Convert the LTA file to the UVFITS format #Generates UVFITS file with same basename as LTA file spam.convert_lta_to_uvfits('Name of the file') #Take generated UVFITS file as input and precalibrate targets #Generates files (RRLL with the name of the source (can be obtained using ltahdr) spam.precalibrate_targets('Name of UVFITS output file') #Take the generated RRLL UVFITS file and process to generate the image #Generates final image <source name>.SP2B.PBCOR.FITS #Also generates log file spam_<source name>_<start date>_start_time>.log in #datfil dir spam.process_target()
Add code for thread to filter valid files for processing
#import spam import filter_lta #List of all directories containing valid observations VALID_FILES = filter_lta.VALID_OBS() #List of all directories for current threads to process THREAD_FILES = VALID_FILES[0:len(VALID_FILES):5] print THREAD_FILES def main(): for i in THREAD_FILES: LTA_FILES = os.chdir(i) """ #Convert the LTA file to the UVFITS format #Generates UVFITS file with same basename as LTA file spam.convert_lta_to_uvfits('Name of the file') #Take generated UVFITS file as input and precalibrate targets #Generates files (RRLL with the name of the source (can be obtained using ltahdr) spam.precalibrate_targets('Name of UVFITS output file') #Take the generated RRLL UVFITS file and process to generate the image #Generates final image <source name>.SP2B.PBCOR.FITS #Also generates log file spam_<source name>_<start date>_start_time>.log in #datfil dir spam.process_target() """
import rospy from time import time def wait_for_param(param_name, timeout=None, poll_rate=0.1): '''Blocking wait for a parameter named $parameter_name to exist Poll at frequency $poll_rate Once the parameter exists, return get and return it. This function intentionally leaves failure logging duties to the developer ''' start_time = time() rate = rospy.Rate(poll_rate) while not rospy.is_shutdown(): # Check if the parameter now exists if rospy.has_param(param_name): return rospy.get_param(param_name) # If we exceed a defined timeout, return None if timeout is not None: if time() - start_time > timeout: return None # Continue to poll at poll_rate rate.sleep()
UTILS: Add init-helper 'wait for subscriber' For integration-testing purposes it is often useful to wait until a particular node subscribes to you
import rospy import rostest import time def wait_for_param(param_name, timeout=None, poll_rate=0.1): '''Blocking wait for a parameter named $parameter_name to exist Poll at frequency $poll_rate Once the parameter exists, return get and return it. This function intentionally leaves failure logging duties to the developer ''' start_time = time.time() rate = rospy.Rate(poll_rate) while not rospy.is_shutdown(): # Check if the parameter now exists if rospy.has_param(param_name): return rospy.get_param(param_name) # If we exceed a defined timeout, return None if timeout is not None: if time.time() - start_time > timeout: return None # Continue to poll at poll_rate rate.sleep() def wait_for_subscriber(node_name, topic, timeout=5.0): '''Blocks until $node_name subscribes to $topic Useful mostly in integration tests -- I would counsel against use elsewhere ''' end_time = time.time() + timeout resolved_topic = rospy.resolve_name(topic) resolved_node = rospy.resolve_name(node_name) # Wait for time-out or ros-shutdown while (time.time() < end_time) and (not rospy.is_shutdown()): subscribed = rostest.is_subscriber( rospy.resolve_name(topic), rospy.resolve_name(node_name) ) # Success scenario: node subscribes if subscribed: break time.sleep(0.1) # Could do this with a while/else # But chose to explicitly check success = rostest.is_subscriber( rospy.resolve_name(topic), rospy.resolve_name(node_name) ) return success