def static_content(environ, start_response): path = getpath(environ) if not path: # redirect start_response('301 Redirect', [content_type(), ('Location', environ['REQUEST_URI'] + '/')]) return [] if path == '/': path = 'web/index.html' # map / to index.html else: path = ('web/' + path).replace('//', '/') if path == 'web/js': # combined java scripts scripts = {} for s in resource_listdir('ctplot', 'web/js'): scripts[s] = '\n// {}\n\n'.format(s) + resource_string('ctplot', 'web/js/' + s) start_response('200 OK', [content_type('combined.js'), cc_cache]) return [scripts[k] for k in sorted(scripts.keys())] if not resource_exists('ctplot', path): # 404 start_response('404 Not Found', [content_type()]) return ['404\n', '{} not found!'.format(path)] elif resource_isdir('ctplot', path): # 403 start_response('403 Forbidden', [content_type()]) return ['403 Forbidden'] else: start_response('200 OK', [content_type(path), cc_cache]) return resource_string('ctplot', path)
def scaffold(output, overrides_output, **kwargs): import pip2nix config = Config() if kwargs['configuration']: config.load(kwargs['configuration']) else: config.find_and_load() config.merge_cli_options(kwargs) # TODO: Config enforces requirements to be specified, find a nicer # way to let Config know that we don't need requirements here. config.merge_options({'pip2nix': {'requirements': []}}) config.validate() import jinja2 raw_template = pkg_resources.resource_string(__name__, 'default.nix.j2') t = jinja2.Template(raw_template.decode('utf-8')) with open(output, 'w') as f: f.write(t.render( package_name=kwargs['package'], pip2nix_version=pip2nix.__version__)) overrides_template = pkg_resources.resource_string( __name__, 'python-packages-overrides.nix.j2') t = jinja2.Template(overrides_template.decode('utf-8')) with open(overrides_output, 'w') as f: f.write(t.render( package_name=kwargs['package'], pip2nix_version=pip2nix.__version__))
def create_config(cfg_dict): """Create the default director.ini in the current directory based on a the template stored in director.templatecfg """ from evasion.director import templatecfg from pkg_resources import resource_string get_log().debug("Creating initial configuration.") # Fill in the template information with viewpoint path: cfg_dict['viewpoint_path'] = '' try: # Attempt to set up the path to the evasion viewpoint XUL app # installed as a python package. from evasion import viewpoint except ImportError: pass else: cfg_dict['viewpoint_path'] = os.path.abspath(viewpoint.__path__[0]) # Fill in the template information with XUL Browser path: t = resource_string(templatecfg.__name__, 'director.cfg.mako') render_config(cfg_dict, t, DEFAULT_CONFIG_NAME) t = resource_string(templatecfg.__name__, 'servicestation.cfg.mako') render_config(cfg_dict, t, DEFAULT_SERVICESTATION_NAME) print("Success, '%s' and '%s' created ok." % (DEFAULT_CONFIG_NAME, DEFAULT_SERVICESTATION_NAME))
def __init__(self): ''' Constructor ''' # Some physical constants # Boltzmann constant self.kb = 1.3806488e-23 # Speed of light self.c = 299792458.0 # Planck constant self.h = 6.62606957e-34 # Load S_n(lambda) for D-illuminant data = resource_string(__name__, 'data/SforD-illuminant.txt') dtypes = {'names': ['wavelen', 'S0', 'S1', 'S2'], 'formats': [float, float, float, float] } self.D_S_Data = np.loadtxt(io.BytesIO(data), dtype=dtypes) # Load Illuminant F Spectrums data = resource_string(__name__, 'data/IlluminantF.txt') dtypes = {'names': ['wavelen', 'F01', 'F02', 'F03', 'F04', 'F05', 'F06', 'F07', 'F08', 'F09', 'F10', 'F11', 'F12' ], 'formats': [float, float, float, float, float, float, float, float, float, float, float, float, float] } self.illumF = np.loadtxt(io.BytesIO(data), dtype=dtypes)
def _install(self): self.requirements, self.ws = self.egg.working_set() parameter_dict = self.computer_partition.getInstanceParameterDict() ipv4 = self.getLocalIPv4Address() ipv6 = self.getGlobalIPv6Address() self.install_mysql_server_configuration(ipv4) port = '8900' tomcat_home = os.path.join(self.data_root_directory, 'tomcat') tomcat_lib = os.path.join(tomcat_home, 'lib') xwiki_home = os.path.join(tomcat_home, 'webapps', 'xwiki') for src, dst in ( (self.options['tomcat_location'].strip(), tomcat_home), (self.options['xwiki_location'].strip(), xwiki_home), ): if not os.path.isdir(dst): try: shutil.copytree(src, dst) except: shtuil.rmtree(dst) raise shutil.copy(self.options['jdbc_location'].strip(), os.path.join(tomcat_lib, 'jdbc.jar')) # headless mode self._writeFile(os.path.join(tomcat_home, 'bin', 'setenv.sh'), '''#!/bin/sh export JAVA_OPTS="${JAVA_OPTS} -Djava.awt.headless=true" ''') # tomcat wrapper catalina = os.path.join(tomcat_home, 'bin', 'catalina.sh') # solve "The BASEDIR environment variable is not defined correctly" bindir = os.path.join(tomcat_home, 'bin') for f in os.listdir(bindir): if f.endswith('.sh'): os.chmod(os.path.join(bindir, f), 0755) tomcat_wrapper = self.createRunningWrapper('xwiki', """#!/bin/sh export JRE_HOME=%(java_home)s exec %(catalina)s run """ % dict(java_home=self.options['java_home'].strip(), catalina = catalina)) tomcat_dict = dict( http_address=ipv6, http_port=port, ajp_address=ipv4, ajp_port="8009", ) server_xml = os.path.join(tomcat_home, 'conf', 'server.xml') self._writeFile(server_xml, pkg_resources.resource_string(__name__, 'template/tomcat-server.xml.in') % tomcat_dict) hibernate_xml = os.path.join(tomcat_home, 'webapps', 'xwiki', 'WEB-INF', 'hibernate.cfg.xml') self._writeFile(hibernate_xml, pkg_resources.resource_string(__name__, 'template/hibernate.cfg.xml.in') % dict(mysql_port='45678', mysql_ip = ipv4)) self.computer_partition.setConnectionDict(dict( http_connection="http://[%s]:%s/xwiki/" % (ipv6, port), )) return [server_xml, tomcat_wrapper]
def resource_string(name, pfx=None): """ Attempt to load and return the contents (as a string) of the resource named by the first argument in the first location of: # as name in the current directory # as name in the `pfx` subdirectory of the current directory if provided # as name relative to the package # as pfx/name relative to the package The last two alternatives is used to locate resources distributed in the package. This includes certain XSLT and XSD files. :param name: The string name of a resource :param pfx: An optional prefix to use in searching for name """ if os.path.exists(name): with open(name) as fd: return fd.read() elif pfx and os.path.exists(os.path.join(pfx, name)): with open(os.path.join(pfx, name)) as fd: return fd.read() elif pkg_resources.resource_exists(__name__, name): return pkg_resources.resource_string(__name__, name) elif pfx and pkg_resources.resource_exists(__name__, "%s/%s" % (pfx, name)): return pkg_resources.resource_string(__name__, "%s/%s" % (pfx, name)) return None
def render(self): output_dir = os.path.join(self.rootdir, "debian") if os.path.exists(output_dir): res = raw_input("A debian directory exists. Replace it? [Y/n]: ") if res.lower() in ["n", "no"]: raise DebianConfigurationException( "Not removing debian directory") shutil.rmtree(output_dir) os.mkdir(output_dir) for template in self.DEBIAN_CONFIGURATION_TEMPLATES: filename = os.path.basename(template).replace(".j2", "") content = Template(resource_string("make_deb", template)) \ .render(self.context) with open(os.path.join(output_dir, filename), "wb") as f: f.write(content) # Need to to trigger separately because filename must change trigger_content = Template( resource_string("make_deb", "resources/debian/triggers.j2") ).render(self.context) trigger_filename = "%s.triggers" % self.context['name'] with open(os.path.join(output_dir, trigger_filename), "wb") as f: f.write(trigger_content+"\n")
def build_webpage(self): html = pk.resource_string(self.res_dir, 'index.html').decode('utf-8') js = pk.resource_string(self.res_dir, 'main.js').decode('utf-8') jsutil = pk.resource_string(self.res_dir, 'util.js').decode('utf-8') css = pk.resource_string(self.res_dir, 'main.css').decode('utf-8') logo = pk.resource_string(self.res_dir, 'sink.png') logo = base64.b64encode(logo).decode('utf-8') # insert js html = html.replace('[[js]]', js) html = html.replace('[[util_js]]', jsutil) # insert css html = html.replace('[[css]]', css) # insert project title project_title = self.data['fields'][1].get('value', 'New Project') html = html.replace('[[project_title]]', project_title) # insert the form self.build_form(self.data['fields'], '') form = self.get_form() html = html.replace('[[form]]', form) # insert logo html = html.replace('[[logo]]', logo) return html
def _test_match(self, game): gt = GosuTicker(game) data = pkg_resources.resource_string('tests', f'/html/match_{game}.html').decode('utf-8') result = pkg_resources.resource_string('tests', f'/html/match_{game}.json').decode('utf-8') sel = Selector(text=data) matches = list(gt.find_matches(sel)) assert json.dumps(matches) == result
def __init__(self): ''' Constructor ''' # Directory for datafiles data = resource_string( __name__, "data/ThorlabsMirrorPF20-03-G01_20deg.txt") # Load A Thorlabs mirror PF20-03-G01 regular reflectance data dtypes = {'names': ['wavelen', 'p-pol', 's-pol', 'ave'], 'formats': [float, float, float, float] } self.PF20_03_G01_deg_20 = np.loadtxt(io.BytesIO(data), dtype=dtypes) data = resource_string( __name__, "data/ThorlabsMirrorPF20-03-G01_8deg.txt") # Load A Thorlabs mirror PF20-03-G01 regular reflectance data dtypes = {'names': ['wavelen', 'p-pol', 's-pol', 'ave'], 'formats': [float, float, float, float] } self.PF20_03_G01_deg_8 = np.loadtxt(io.BytesIO(data), dtype=dtypes)
def openNode(self, platform_id, node_config_filename, stream_definition_filename=DEFAULT_STREAM_DEF_FILENAME): """ Opens up and parses the node configuration files. @param platform_id - id to associate with this set of Node Configuration Files @param nc_file - yaml file with information about the platform @raise NodeConfigurationException """ try: node_config_string = resource_string(mi.platform.rsn.__name__, node_config_filename) stream_config_string = resource_string(mi.platform.rsn.__name__, stream_definition_filename) self._platform_id = platform_id node_config = yaml.load(node_config_string) stream_definitions = yaml.load(stream_config_string) self._node_yaml = NodeYAML.factory(node_config, stream_definitions) self._node_yaml.validate() except Exception as e: import traceback traceback.print_exc() msg = "%s Cannot parse yaml node specific config file : %s" % (e, node_config_filename) raise NodeConfigurationFileException(msg=msg) except IOError as e: msg = "%s Cannot open node specific config file : %s" % (e, node_config_filename) raise NodeConfigurationFileException(msg=msg)
def student_view(self, context): """ Create a fragment used to display the XBlock to a student. `context` is a dictionary used to configure the display (unused) Returns a `Fragment` object specifying the HTML, CSS, and JavaScript to display. """ provider, embed_code = self.get_embed_code_for_url(self.href) # Load the HTML fragment from within the package and fill in the template html_str = pkg_resources.resource_string(__name__, "static/html/simplevideo.html") frag = Fragment(unicode(html_str).format(self=self, embed_code=embed_code)) # Load CSS css_str = pkg_resources.resource_string(__name__, "static/css/simplevideo.css") frag.add_css(unicode(css_str)) # Load JS if provider == 'vimeo.com': # Load the Froogaloop library from vimeo CDN. frag.add_javascript_url("//f.vimeocdn.com/js/froogaloop2.min.js") js_str = pkg_resources.resource_string(__name__, "static/js/simplevideo.js") frag.add_javascript(unicode(js_str)) frag.initialize_js('SimpleVideoBlock') return frag
def setUp(self): if "NTA_DYNAMIC_CONF_DIR" in os.environ: # Remove it to make sure our in-proc tests won't accidentally # mess with actual files oldNtaDynamicConfDir = os.environ["NTA_DYNAMIC_CONF_DIR"] del os.environ["NTA_DYNAMIC_CONF_DIR"] self.addCleanup(os.environ.update, dict(NTA_DYNAMIC_CONF_DIR=oldNtaDynamicConfDir)) self.files = dict() tmpDir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, tmpDir) with open(os.path.join(tmpDir, 'nupic-default.xml-unittest'), 'w') as fp: fp.write(resource_string(__name__, 'conf/nupic-default.xml')) self.files['nupic-default.xml'] = fp.name with open(os.path.join(tmpDir, 'nupic-site.xml-unittest'), 'w') as fp: fp.write(resource_string(__name__, 'conf/nupic-site.xml')) self.files['nupic-site.xml'] = fp.name with open(os.path.join(tmpDir, 'nupic-custom.xml'), 'w') as fp: fp.write(resource_string(__name__, 'conf/nupic-custom.xml')) self.files['nupic-custom.xml'] = fp.name self.customParam = 'nupic.custom.hello' self.customValue = 'world' configuration.Configuration.clear()
def setUp(self): super(TabsEditingDescriptorTestCase, self).setUp() system = get_test_system() system.render_template = Mock(return_value="<div>Test Template HTML</div>") self.tabs = [ { 'name': "Test_css", 'template': "tabs/codemirror-edit.html", 'current': True, 'css': { 'scss': [resource_string(__name__, '../../test_files/test_tabseditingdescriptor.scss')], 'css': [resource_string(__name__, '../../test_files/test_tabseditingdescriptor.css')] } }, { 'name': "Subtitles", 'template': "videoalpha/subtitles.html", }, { 'name': "Settings", 'template': "tabs/video-metadata-edit-tab.html" } ] TabsEditingDescriptor.tabs = self.tabs self.descriptor = TabsEditingDescriptor( runtime=system, model_data={})
def useComputer(self, computer_id, use_string): """Entry point to reporting usage of a computer.""" #We retrieve XSD model try: computer_consumption_model = \ pkg_resources.resource_string( 'slapos.slap', 'doc/computer_consumption.xsd') except IOError: computer_consumption_model = \ pkg_resources.resource_string( __name__, '../../../../slapos/slap/doc/computer_consumption.xsd') if self._validateXML(use_string, computer_consumption_model): vifib_conduit_instance = VifibConduit.VifibConduit() #We create the SPL vifib_conduit_instance.addNode( object=self, xml=use_string, computer_id=computer_id) else: raise NotImplementedError("XML file sent by the node is not valid !") return 'Content properly posted.'
def test_refextract_url(log_in_as_cataloger, api_client): schema = load_schema('hep') subschema = schema['properties']['references'] with requests_mock.Mocker() as requests_mocker: requests_mocker.register_uri( 'GET', 'https://arxiv.org/pdf/1612.06414.pdf', content=pkg_resources.resource_string( __name__, os.path.join('fixtures', '1612.06414.pdf')), ) requests_mocker.register_uri( 'GET', 'http://test-indexer:9200/records-hep/hep/_search?_source=control_number', content=pkg_resources.resource_string( __name__, os.path.join('fixtures', 'es_response.json')), ) response = api_client.post( '/editor/refextract/url', content_type='application/json', data=json.dumps({ 'url': 'https://arxiv.org/pdf/1612.06414.pdf', }), ) references = json.loads(response.data) assert response.status_code == 200 assert validate(references, subschema) is None assert get_value({'references': references}, 'references.reference.publication_info.journal_title')
def gen_resjs(self): """genarate res.js, should be called after added all resources """ res_ajax = resource_string(__name__, 'res/res-ajax.js').decode("utf-8") res_core = resource_string(__name__, 'res/res-core.js').decode("utf-8") res_js = res_ajax + os.linesep + res_core self._gen_from_template(res_js, self.resjs_name)
def setUp(self): super(TabsEditingDescriptorTestCase, self).setUp() system = get_test_descriptor_system() system.render_template = Mock(return_value="<div>Test Template HTML</div>") self.tabs = [ { 'name': "Test_css", 'template': "tabs/codemirror-edit.html", 'current': True, 'css': { 'scss': [resource_string(__name__, '../../test_files/test_tabseditingdescriptor.scss')], 'css': [resource_string(__name__, '../../test_files/test_tabseditingdescriptor.css')] } }, { 'name': "Subtitles", 'template': "video/subtitles.html", }, { 'name': "Settings", 'template': "tabs/video-metadata-edit-tab.html" } ] TabsEditingDescriptor.tabs = self.tabs self.descriptor = system.construct_xblock_from_class( TabsEditingDescriptor, field_data=DictFieldData({}), scope_ids=ScopeIds(None, None, None, None), )
def _gen_options_reference(self): """Generate the options reference rst doc.""" goals = gen_tasks_options_reference_data() filtered_goals = [] omit_impl_regexps = [re.compile(r) for r in self.get_options().omit_impl_re] for g in goals: if any(r.match(t['impl']) for r in omit_impl_regexps for t in g.tasks): continue filtered_goals.append(g) glopts = gen_glopts_reference_data() # generate the .rst file template = resource_string(__name__, os.path.join(self._templates_dir, 'options_reference.mustache')) filename = os.path.join(self._outdir, 'options_reference.rst') self.context.log.info('Generating {}'.format(filename)) with safe_open(filename, 'wb') as outfile: generator = Generator(template, goals=filtered_goals, glopts=glopts) generator.write(outfile) # generate the .html file template = resource_string(__name__, os.path.join(self._templates_dir, 'oref_html.mustache')) filename = os.path.join(self._outdir, 'options_reference.html') self.context.log.info('Generating {}'.format(filename)) with safe_open(filename, 'wb') as outfile: generator = Generator(template, goals=filtered_goals, glopts=glopts) generator.write(outfile)
def setup_db(db_uri='test.db'): #Import sql schema if 'postgres://' in db_uri: import psycopg2 connection = psycopg2.connect(db_uri) cursor = connection.cursor() cursor.execute(resource_string(__name__, 'schema.sql')) connection.commit() cursor.close() else: import sqlite3 connection = sqlite3.connect(db_uri) cursor = connection.cursor() schema = resource_string(__name__, 'schema.sql') if isinstance(schema, bytes): schema = schema.decode("utf-8") cursor.executescript(schema) connection.commit() cursor.close() connection.close() return True
def put_file(dest, src, opt_dict=None): fh = open(dest, 'w') if opt_dict is not None: fh.write(pkg_resources.resource_string('webias', src) % opt_dict) else: fh.write(pkg_resources.resource_string('webias', src)) fh.close()
def create_chart(self, html_path='index.html', data_path='data.json', js_path='rickshaw.min.js', css_path='rickshaw.min.css', html_prefix=''): '''Save bearcart output to HTML and JSON. Parameters ---------- html_path: string, default 'index.html' Path for html output data_path: string, default 'data.json' Path for data JSON output js_path: string, default 'rickshaw.min.js' If passed, the Rickshaw javascript library will be saved to the path. The file must be named "rickshaw.min.js" css_path: string, default 'rickshaw.min.css' If passed, the Rickshaw css library will be saved to the path. The file must be named "rickshaw.min.css" html_prefix: Prefix path to be appended to all the other paths for file creation, but not in the generated html file. This is needed if the html file does not live in the same folder as the running python script. Returns ------- HTML, JSON, JS, and CSS Example -------- >>>vis.create_chart(html_path='myvis.html', data_path='visdata.json'), js_path='rickshaw.min.js', cs_path='rickshaw.min.css') ''' self.template_vars.update({'data_path': str(data_path), 'js_path': js_path, 'css_path': css_path, 'chart_id': self.chart_id, 'y_axis_id': self.y_axis_id, 'legend_id': self.legend_id, 'slider_id': self.slider_id}) self._build_graph() html = self.env.get_template('bcart_template.html') self.HTML = html.render(self.template_vars) with open(os.path.join(html_prefix, html_path), 'w') as f: f.write(self.HTML) with open(os.path.join(html_prefix, data_path), 'w') as f: json.dump(self.json_data, f, sort_keys=True, indent=4, separators=(',', ': ')) if js_path: js = resource_string('bearcart', 'rickshaw.min.js') with open(os.path.join(html_prefix, js_path), 'w') as f: f.write(js) if css_path: css = resource_string('bearcart', 'rickshaw.min.css') with open(os.path.join(html_prefix, css_path), 'w') as f: f.write(css)
def student_view(self, context): """ Generate the html code to display the XBlock to a student `context` is a dictionary used to configure the display (unused). Returns a `Fragment` object specifying the HTML, CSS, and JavaScript to display. """ provider, embed_code = self.get_embed_code_for_url(self.href) # Retrieve HTML code for video iframe html_code = pkg_resources.resource_string(__name__, "static/html/cnvideo.html") frag = Fragment(unicode(html_code).format(self=self, embed_code=embed_code)) # Load CSS css_str = pkg_resources.resource_string(__name__, "static/css/cnvideo.css") frag.add_css(css_str) # Load vimeo JS API and custom js for watching views if provider == "vimeo.com": frag.add_javascript_url("//f.vimeocdn.com/js/froogaloop2.min.js") js_str = pkg_resources.resource_string(__name__, "static/js/cnvideo.js") frag.add_javascript(unicode(js_str)) frag.initialize_js("cnVideoBlock") return frag
def run_jenkins_now( jenkins_instance, ubuntu_distro, arch, job_name, email, script, script_args, user_name, parameters=None, matrix=None ): job_xml = pkg_resources.resource_string("jenkins_tools", "resources/templates/jenkins_template.xml") jenkins_conf = pkg_resources.resource_string("jenkins_tools", "resources/templates/jenkins_conf.yaml") jc = yaml.load(jenkins_conf) # get arguments params = {} params["UBUNTU_DISTRO"] = ubuntu_distro params["ARCH"] = arch params["EMAIL"] = email params["EMAIL_COMMITTER"] = "false" params["SCRIPT"] = script params["NODE"] = params["SCRIPT"] params["SCRIPT_ARGS"] = " ".join(script_args) params["TRIGGER"] = jc["triggers"]["none"] params["VCS"] = jc["vcs"]["none"] params["TIME"] = str(datetime.datetime.now()) params["USERNAME"] = user_name params["HOSTNAME"] = os.uname()[1] params["PARAMETERS"] = "" params["MATRIX"] = "" params["PROJECT"] = "project" if parameters and len(parameters) > 0: params["PARAMETERS"] = jc["parameters"]["block"].replace( "@(PARAMS)", " ".join([jc["parameters"]["param"].replace("@(PARAM)", p) for p in parameters[0].keys()]) ) if matrix: axis = "" for axis_name, axis_values in matrix.iteritems(): axis += ( jc["matrix"]["axis"] .replace("@(NAME)", axis_name) .replace("@(VALUES)", " ".join([jc["matrix"]["value"].replace("@(VALUE)", v) for v in axis_values])) ) params["MATRIX"] = jc["matrix"]["block"].replace("@(AXIS)", axis) params["MATRIX"] = params["MATRIX"].replace("@(NODE)", params["NODE"]) params["PROJECT"] = "matrix-project" # replace @(xxx) in template file for key, value in params.iteritems(): job_xml = job_xml.replace("@(%s)" % key, value) # schedule a new job if jenkins_instance.job_exists(job_name): jenkins_instance.reconfig_job(job_name, job_xml) print "Reconfigured job %s" % job_name else: jenkins_instance.create_job(job_name, job_xml) print "Created job %s" % job_name # build all jobs if not parameters or len(parameters) == 0: jenkins_instance.build_job(job_name) else: for p in parameters: jenkins_instance.build_job(job_name, p) print "Started job %s" % job_name
def response_template_to_json(template_name): rsc_path = "/".join(("sample_responses", template_name)) try: # Python 3.3 will return the contents as a bytes-like object. file_contents = pkg_resources.resource_string(rsc_pkg, rsc_path).decode("utf-8") except AttributeError: file_contents = pkg_resources.resource_string(rsc_pkg, rsc_path) return json.loads(file_contents)
def on_app_start(self, data = None): # create widget tree ... self.builder = Gtk.Builder() self.ui_manager = Gtk.UIManager() try: self.builder.add_from_file(resource_string(__name__, 'stevedore.glade')) self.ui_manager.add_ui_from_file(resource_string(__name__, 'ui_builder.xml')) except: self.builder.add_from_file('../res/stevedore.glade') self.ui_manager.add_ui_from_file('../res/ui_builder.xml') # connect handlers self.builder.connect_signals(self) self.ui_manager.insert_action_group(self.builder.get_object('ContainerActionGroup')) self.ui_manager.insert_action_group(self.builder.get_object('ImagesActionGroup')) # Prepare certain widgets self.status_bar = self.builder.get_object('AppStatus') self.status_context_id = self.status_bar.get_context_id('main_app') self.builder.get_object('StartButton').set_sensitive(False) self.builder.get_object('StopButton').set_sensitive(False) self.builder.get_object('AttachButton').set_sensitive(False) self.builder.get_object('LogButton').set_sensitive(False) self.builder.get_object('DeleteContainerButton').set_sensitive(False) # Add window to the App and show it self.window = self.builder.get_object('MainWindow') self.add_window(self.window) self.window.show() self.set_app_status(u'Not connected to Docker server.')
def setUp(self): """Setup tests.""" from inspire.modules.workflows.receivers import precache_holdingpen_row from invenio_workflows.receivers import index_holdingpen_record from invenio_workflows.signals import workflow_halted, workflow_object_saved # Disable the holdingpen caching receiver. workflow_halted.disconnect(precache_holdingpen_row) workflow_object_saved.disconnect(index_holdingpen_record) self.create_registries() self.record_oai_arxiv_plots = pkg_resources.resource_string( "inspire.testsuite", os.path.join("workflows", "fixtures", "oai_arxiv_record_with_plots.xml") ) self.record_oai_arxiv_accept = pkg_resources.resource_string( "inspire.testsuite", os.path.join("workflows", "fixtures", "oai_arxiv_record_to_accept.xml") ) self.some_record = pkg_resources.resource_string( "inspire.testsuite", os.path.join("workflows", "fixtures", "some_record.xml") ) self.arxiv_tarball = pkg_resources.resource_stream( "inspire.testsuite", os.path.join("workflows", "fixtures", "1407.7587v1") ) self.arxiv_pdf = pkg_resources.resource_stream( "inspire.testsuite", os.path.join("workflows", "fixtures", "1407.7587v1.pdf") ) self.arxiv_tarball_accept = pkg_resources.resource_stream( "inspire.testsuite", os.path.join("workflows", "fixtures", "1511.01097") ) self.arxiv_pdf_accept = pkg_resources.resource_stream( "inspire.testsuite", os.path.join("workflows", "fixtures", "1511.01097v1.pdf") )
def run_jenkins_vcs(jenkins_instance, ubuntu_distro, arch, name, email, vcs, uri, branch, script, script_args, user_name): job_xml = pkg_resources.resource_string('jenkins_tools', 'resources/templates/jenkins_template.xml') jenkins_conf = pkg_resources.resource_string('jenkins_tools', 'resources/templates/jenkins_conf.yaml') jc = yaml.load(jenkins_conf) # get arguments params = {} params['UBUNTU_DISTRO'] = ubuntu_distro params['ARCH'] = arch params['EMAIL'] = email params['TRIGGER'] = jc['triggers']['vcs'] params['VCS'] = jc['vcs'][vcs].replace('@(URI)', uri).replace('@(BRANCH)', branch) params['SCRIPT'] = script params['NODE'] = params['SCRIPT'] params['TIME'] = str(datetime.datetime.now()) params['SCRIPT_ARGS'] = ' '.join(script_args) params['USERNAME'] = user_name params['HOSTNAME'] = os.uname()[1] # replace @(xxx) in template file for key, value in params.iteritems(): job_xml = job_xml.replace("@(%s)"%key, value) # schedule a new job job_name = "%s-%s-%s-%s"%(params['SCRIPT'], name, params['UBUNTU_DISTRO'], params['ARCH']) if jenkins_instance.job_exists(job_name): jenkins_instance.reconfig_job(job_name, job_xml) print "Reconfigured job %s"%job_name else: jenkins_instance.create_job(job_name, job_xml) print "Created job %s"%job_name return job_name
def init(self, path): settings = {} t = raw_input('Debug Mode [n]:') settings['debug'] = 'True' if t.lower() == 'y' else 'False' t = raw_input('Port [5000]:') settings['port'] = t if t.strip() else '5000' t = raw_input('MySQL Host [localhost]:') settings['db_host'] = t if t.strip() else 'localhost' t = raw_input('MySQL Port [3306]:') settings['db_port'] = t if t.strip() else '3306' t = raw_input('MySQL User [ngflaskcurd]:') settings['db_user'] = t if t.strip() else 'ngflaskcurd' t = raw_input('MySQL Password:'******'db_pwd'] = t t = raw_input('MySQL Database Name [ngflaskcurd]:') settings['db_db'] = t if t.strip() else 'ngflaskcurd' a2wsgi = {} a2wsgi['dir'] = os.path.abspath(path) with open(os.path.join(path, 'setting.py'), 'w') as fd: fd.write(pkg_resources.resource_string( 'ngflaskcurd', 'config_templates/settings.py') % settings) with open(os.path.join(path, 'run.py'), 'w') as fd: fd.write(Template(pkg_resources.resource_string( 'ngflaskcurd', 'wsgi.py')).substitute(a2wsgi)) if not os.path.exists(os.path.join(path, 'log')): os.mkdir(os.path.join(path, 'log'))
def setUp(self): self.marcxml = pkg_resources.resource_string('tests', os.path.join( 'fixtures', 'test_hep_formats.xml') ) self.marcxml_publi_info = pkg_resources.resource_string('tests', os.path.join( 'fixtures', 'test_hep_publi_info.xml') ) record = create_record(self.marcxml) record_publi_info = create_record(self.marcxml_publi_info) self.hep_record = hep.do(record) self.hep_record_publi_info = hep.do(record_publi_info) self.sample_cv_latex = { 'author': 'G.~Aad', 'title': "{\\bf ``\nSearch for supersymmetry in events containing a same-flavour opposite-sign dilepton pair, jets, and large missing transverse momentum in $\sqrt{s}=8$ TeV $pp$ collisions with the ATLAS detector\n''}", 'publi_info': ['Eur.\ Phys.\ J.\ C {\\bf 75}, no. 7, 318 (2015)', '[Eur.\ Phys.\ J.\ C {\\bf 75}, no. 10, 463 (2015)]'], 'url': cfg['CFG_SITE_URL'] + '/record/1351762', 'date': 'Mar 11, 2015' } self.sample_cv_latex_publi_info = { 'publi_info': ['Class.\\ Quant.\\ Grav.\\ {\\bf 15}, 2153 (1998)'] }
class CapaDescriptor(CapaFields, RawDescriptor): """ Module implementing problems in the LON-CAPA format, as implemented by capa.capa_problem """ module_class = CapaModule has_score = True template_dir_name = 'problem' mako_template = "widgets/problem-edit.html" js = {'coffee': [resource_string(__name__, 'js/src/problem/edit.coffee')]} js_module_name = "MarkdownEditingDescriptor" css = { 'scss': [ resource_string(__name__, 'css/editor/edit.scss'), resource_string(__name__, 'css/problem/edit.scss') ] } # The capa format specifies that what we call max_attempts in the code # is the attribute `attempts`. This will do that conversion metadata_translations = dict(RawDescriptor.metadata_translations) metadata_translations['attempts'] = 'max_attempts' @classmethod def filter_templates(cls, template, course): """ Filter template that contains 'latex' from templates. Show them only if use_latex_compiler is set to True in course settings. """ return (not 'latex' in template['template_id'] or course.use_latex_compiler) def get_context(self): _context = RawDescriptor.get_context(self) _context.update({ 'markdown': self.markdown, 'enable_markdown': self.markdown is not None, 'enable_latex_compiler': self.use_latex_compiler, }) return _context # VS[compat] # TODO (cpennington): Delete this method once all fall 2012 course are being # edited in the cms @classmethod def backcompat_paths(cls, path): return [ 'problems/' + path[8:], path[8:], ] @property def non_editable_metadata_fields(self): non_editable_fields = super(CapaDescriptor, self).non_editable_metadata_fields non_editable_fields.extend([ CapaDescriptor.due, CapaDescriptor.graceperiod, CapaDescriptor.force_save_button, CapaDescriptor.markdown, CapaDescriptor.text_customization, CapaDescriptor.use_latex_compiler, ]) return non_editable_fields # Proxy to CapaModule for access to any of its attributes answer_available = module_attr('answer_available') check_button_name = module_attr('check_button_name') check_button_checking_name = module_attr('check_button_checking_name') check_problem = module_attr('check_problem') choose_new_seed = module_attr('choose_new_seed') closed = module_attr('closed') get_answer = module_attr('get_answer') get_problem = module_attr('get_problem') get_problem_html = module_attr('get_problem_html') get_state_for_lcp = module_attr('get_state_for_lcp') handle_input_ajax = module_attr('handle_input_ajax') handle_problem_html_error = module_attr('handle_problem_html_error') handle_ungraded_response = module_attr('handle_ungraded_response') is_attempted = module_attr('is_attempted') is_correct = module_attr('is_correct') is_past_due = module_attr('is_past_due') is_submitted = module_attr('is_submitted') lcp = module_attr('lcp') make_dict_of_responses = module_attr('make_dict_of_responses') new_lcp = module_attr('new_lcp') publish_grade = module_attr('publish_grade') rescore_problem = module_attr('rescore_problem') reset_problem = module_attr('reset_problem') save_problem = module_attr('save_problem') set_state_from_lcp = module_attr('set_state_from_lcp') should_show_check_button = module_attr('should_show_check_button') should_show_reset_button = module_attr('should_show_reset_button') should_show_save_button = module_attr('should_show_save_button') update_score = module_attr('update_score')
class CapaModule(CapaMixin, XModule): """ An XModule implementing LonCapa format problems, implemented by way of capa.capa_problem.LoncapaProblem CapaModule.__init__ takes the same arguments as xmodule.x_module:XModule.__init__ """ icon_class = 'problem' js = { 'js': [ resource_string(__name__, 'js/src/javascript_loader.js'), resource_string(__name__, 'js/src/capa/display.js'), resource_string(__name__, 'js/src/collapsible.js'), resource_string(__name__, 'js/src/capa/imageinput.js'), resource_string(__name__, 'js/src/capa/schematic.js'), ] } js_module_name = "Problem" css = {'scss': [resource_string(__name__, 'css/capa/display.scss')]} def author_view(self, context): """ Renders the Studio preview view. """ return self.student_view(context) def handle_ajax(self, dispatch, data): """ This is called by courseware.module_render, to handle an AJAX call. `data` is request.POST. Returns a json dictionary: { 'progress_changed' : True/False, 'progress' : 'none'/'in_progress'/'done', <other request-specific values here > } """ handlers = { 'hint_button': self.hint_button, 'problem_get': self.get_problem, 'problem_check': self.submit_problem, 'problem_reset': self.reset_problem, 'problem_save': self.save_problem, 'problem_show': self.get_answer, 'score_update': self.update_score, 'input_ajax': self.handle_input_ajax, 'ungraded_response': self.handle_ungraded_response } _ = self.runtime.service(self, "i18n").ugettext generic_error_message = _( "We're sorry, there was an error with processing your request. " "Please try reloading your page and trying again.") not_found_error_message = _( "The state of this problem has changed since you loaded this page. " "Please refresh your page.") if dispatch not in handlers: return 'Error: {} is not a known capa action'.format(dispatch) before = self.get_progress() before_attempts = self.attempts try: result = handlers[dispatch](data) except NotFoundError: log.info( "Unable to find data when dispatching %s to %s for user %s", dispatch, self.scope_ids.usage_id, self.scope_ids.user_id) _, _, traceback_obj = sys.exc_info() # pylint: disable=redefined-outer-name raise ProcessingError(not_found_error_message), None, traceback_obj except Exception: log.exception( "Unknown error when dispatching %s to %s for user %s", dispatch, self.scope_ids.usage_id, self.scope_ids.user_id) _, _, traceback_obj = sys.exc_info() # pylint: disable=redefined-outer-name raise ProcessingError(generic_error_message), None, traceback_obj after = self.get_progress() after_attempts = self.attempts progress_changed = (after != before) or (after_attempts != before_attempts) curr_score, total_possible = self.get_display_progress() result.update({ 'progress_changed': progress_changed, 'current_score': curr_score, 'total_possible': total_possible, 'attempts_used': after_attempts, }) return json.dumps(result, cls=ComplexEncoder) @property def display_name_with_default(self): """ Constructs the display name for a CAPA problem. Default to the display_name if it isn't None or not an empty string, else fall back to problem category. """ if self.display_name is None or not self.display_name.strip(): return self.location.block_type return self.display_name
class CapaDescriptor(CapaFields, RawDescriptor): """ Module implementing problems in the LON-CAPA format, as implemented by capa.capa_problem """ INDEX_CONTENT_TYPE = 'CAPA' module_class = CapaModule resources_dir = None has_score = True show_in_read_only_mode = True template_dir_name = 'problem' mako_template = "widgets/problem-edit.html" js = {'js': [resource_string(__name__, 'js/src/problem/edit.js')]} js_module_name = "MarkdownEditingDescriptor" has_author_view = True css = { 'scss': [ resource_string(__name__, 'css/editor/edit.scss'), resource_string(__name__, 'css/problem/edit.scss') ] } # The capa format specifies that what we call max_attempts in the code # is the attribute `attempts`. This will do that conversion metadata_translations = dict(RawDescriptor.metadata_translations) metadata_translations['attempts'] = 'max_attempts' @classmethod def filter_templates(cls, template, course): """ Filter template that contains 'latex' from templates. Show them only if use_latex_compiler is set to True in course settings. """ return 'latex' not in template[ 'template_id'] or course.use_latex_compiler def get_context(self): _context = RawDescriptor.get_context(self) _context.update({ 'markdown': self.markdown, 'enable_markdown': self.markdown is not None, 'enable_latex_compiler': self.use_latex_compiler, }) return _context # VS[compat] # TODO (cpennington): Delete this method once all fall 2012 course are being # edited in the cms @classmethod def backcompat_paths(cls, path): dog_stats_api.increment( DEPRECATION_VSCOMPAT_EVENT, tags=["location:capa_descriptor_backcompat_paths"]) return [ 'problems/' + path[8:], path[8:], ] @property def non_editable_metadata_fields(self): non_editable_fields = super(CapaDescriptor, self).non_editable_metadata_fields non_editable_fields.extend([ CapaDescriptor.due, CapaDescriptor.graceperiod, CapaDescriptor.force_save_button, CapaDescriptor.markdown, CapaDescriptor.use_latex_compiler, CapaDescriptor.show_correctness, ]) return non_editable_fields @property def problem_types(self): """ Low-level problem type introspection for content libraries filtering by problem type """ try: tree = etree.XML(self.data) except etree.XMLSyntaxError: log.error( 'Error parsing problem types from xml for capa module {}'. format(self.display_name)) return None # short-term fix to prevent errors (TNL-5057). Will be more properly addressed in TNL-4525. registered_tags = responsetypes.registry.registered_tags() return { node.tag for node in tree.iter() if node.tag in registered_tags } def index_dictionary(self): """ Return dictionary prepared with module content and type for indexing. """ xblock_body = super(CapaDescriptor, self).index_dictionary() # Removing solutions and hints, as well as script and style capa_content = re.sub( re.compile( r""" <solution>.*?</solution> | <script>.*?</script> | <style>.*?</style> | <[a-z]*hint.*?>.*?</[a-z]*hint> """, re.DOTALL | re.VERBOSE), "", self.data) capa_content = escape_html_characters(capa_content) capa_body = { "capa_content": capa_content, "display_name": self.display_name, } if "content" in xblock_body: xblock_body["content"].update(capa_body) else: xblock_body["content"] = capa_body xblock_body["content_type"] = self.INDEX_CONTENT_TYPE xblock_body["problem_types"] = list(self.problem_types) return xblock_body def has_support(self, view, functionality): """ Override the XBlock.has_support method to return appropriate value for the multi-device functionality. Returns whether the given view has support for the given functionality. """ if functionality == "multi_device": types = self.problem_types # Avoid calculating this property twice return types is not None and all( responsetypes.registry.get_class_for_tag( tag).multi_device_support for tag in types) return False def max_score(self): """ Return the problem's max score """ from capa.capa_problem import LoncapaProblem, LoncapaSystem capa_system = LoncapaSystem( ajax_url=None, anonymous_student_id=None, cache=None, can_execute_unsafe_code=None, get_python_lib_zip=None, DEBUG=None, filestore=self.runtime.resources_fs, i18n=self.runtime.service(self, "i18n"), node_path=None, render_template=None, seed=None, STATIC_URL=None, xqueue=None, matlab_api_key=None, ) lcp = LoncapaProblem( problem_text=self.data, id=self.location.html_id(), capa_system=capa_system, capa_module=self, state={}, seed=1, minimal_init=True, ) return lcp.get_max_score() def generate_report_data(self, user_state_iterator, limit_responses=None): """ Return a list of student responses to this block in a readable way. Arguments: user_state_iterator: iterator over UserStateClient objects. E.g. the result of user_state_client.iter_all_for_block(block_key) limit_responses (int|None): maximum number of responses to include. Set to None (default) to include all. Returns: each call returns a tuple like: ("username", { "Question": "2 + 2 equals how many?", "Answer": "Four", "Answer ID": "98e6a8e915904d5389821a94e48babcf_10_1" }) """ from capa.capa_problem import LoncapaProblem, LoncapaSystem if self.category != 'problem': raise NotImplementedError() if limit_responses == 0: # Don't even start collecting answers return capa_system = LoncapaSystem( ajax_url=None, # TODO set anonymous_student_id to the anonymous ID of the user which answered each problem # Anonymous ID is required for Matlab, CodeResponse, and some custom problems that include # '$anonymous_student_id' in their XML. # For the purposes of this report, we don't need to support those use cases. anonymous_student_id=None, cache=None, can_execute_unsafe_code=lambda: None, get_python_lib_zip=lambda: None, DEBUG=None, filestore=self.runtime.resources_fs, i18n=self.runtime.service(self, "i18n"), node_path=None, render_template=None, seed=1, STATIC_URL=None, xqueue=None, matlab_api_key=None, ) _ = capa_system.i18n.ugettext count = 0 for user_state in user_state_iterator: if 'student_answers' not in user_state.state: continue lcp = LoncapaProblem( problem_text=self.data, id=self.location.html_id(), capa_system=capa_system, # We choose to run without a fully initialized CapaModule capa_module=None, state={ 'done': user_state.state.get('done'), 'correct_map': user_state.state.get('correct_map'), 'student_answers': user_state.state.get('student_answers'), 'has_saved_answers': user_state.state.get('has_saved_answers'), 'input_state': user_state.state.get('input_state'), 'seed': user_state.state.get('seed'), }, seed=user_state.state.get('seed'), # extract_tree=False allows us to work without a fully initialized CapaModule # We'll still be able to find particular data in the XML when we need it extract_tree=False, ) for answer_id, orig_answers in lcp.student_answers.items(): # Some types of problems have data in lcp.student_answers that isn't in lcp.problem_data. # E.g. formulae do this to store the MathML version of the answer. # We exclude these rows from the report because we only need the text-only answer. if answer_id.endswith('_dynamath'): continue if limit_responses and count >= limit_responses: # End the iterator here return question_text = lcp.find_question_label(answer_id) answer_text = lcp.find_answer_text(answer_id, current_answer=orig_answers) count += 1 yield (user_state.username, { _("Answer ID"): answer_id, _("Question"): question_text, _("Answer"): answer_text, }) # Proxy to CapaModule for access to any of its attributes answer_available = module_attr('answer_available') submit_button_name = module_attr('submit_button_name') submit_button_submitting_name = module_attr( 'submit_button_submitting_name') submit_problem = module_attr('submit_problem') choose_new_seed = module_attr('choose_new_seed') closed = module_attr('closed') get_answer = module_attr('get_answer') get_problem = module_attr('get_problem') get_problem_html = module_attr('get_problem_html') get_state_for_lcp = module_attr('get_state_for_lcp') handle_input_ajax = module_attr('handle_input_ajax') hint_button = module_attr('hint_button') handle_problem_html_error = module_attr('handle_problem_html_error') handle_ungraded_response = module_attr('handle_ungraded_response') has_submitted_answer = module_attr('has_submitted_answer') is_attempted = module_attr('is_attempted') is_correct = module_attr('is_correct') is_past_due = module_attr('is_past_due') is_submitted = module_attr('is_submitted') lcp = module_attr('lcp') make_dict_of_responses = module_attr('make_dict_of_responses') new_lcp = module_attr('new_lcp') publish_grade = module_attr('publish_grade') rescore = module_attr('rescore') reset_problem = module_attr('reset_problem') save_problem = module_attr('save_problem') set_score = module_attr('set_score') set_state_from_lcp = module_attr('set_state_from_lcp') should_show_submit_button = module_attr('should_show_submit_button') should_show_reset_button = module_attr('should_show_reset_button') should_show_save_button = module_attr('should_show_save_button') update_score = module_attr('update_score')
pass from . import checklistdb #from . import canonicalize_path from . import xmldoc from . import dc_value class dummy(object): pass thisdir = os.path.split(sys.modules[dummy.__module__].__file__)[0] try: __install_prefix__ = resource_string(__name__, 'install_prefix.txt').decode('utf-8') pass except (IOError, NameError): sys.stderr.write( "dc2_misc: error reading install_prefix.txt. Assuming /usr/local.\n") __install_prefix__ = "/usr/local" pass def getconfigurlpath(): return [ pathname2url( os.path.join(__install_prefix__, "share", "limatix", "conf")) ]
class CapaDescriptor(CapaFields, RawDescriptor): """ Module implementing problems in the LON-CAPA format, as implemented by capa.capa_problem """ INDEX_CONTENT_TYPE = 'CAPA' module_class = CapaModule resources_dir = None has_score = True show_in_read_only_mode = True template_dir_name = 'problem' mako_template = "widgets/problem-edit.html" js = {'js': [resource_string(__name__, 'js/src/problem/edit.js')]} js_module_name = "MarkdownEditingDescriptor" has_author_view = True css = { 'scss': [ resource_string(__name__, 'css/editor/edit.scss'), resource_string(__name__, 'css/problem/edit.scss') ] } # The capa format specifies that what we call max_attempts in the code # is the attribute `attempts`. This will do that conversion metadata_translations = dict(RawDescriptor.metadata_translations) metadata_translations['attempts'] = 'max_attempts' @classmethod def filter_templates(cls, template, course): """ Filter template that contains 'latex' from templates. Show them only if use_latex_compiler is set to True in course settings. """ return 'latex' not in template[ 'template_id'] or course.use_latex_compiler def get_context(self): _context = RawDescriptor.get_context(self) _context.update({ 'markdown': self.markdown, 'enable_markdown': self.markdown is not None, 'enable_latex_compiler': self.use_latex_compiler, }) return _context # VS[compat] # TODO (cpennington): Delete this method once all fall 2012 course are being # edited in the cms @classmethod def backcompat_paths(cls, path): dog_stats_api.increment( DEPRECATION_VSCOMPAT_EVENT, tags=["location:capa_descriptor_backcompat_paths"]) return [ 'problems/' + path[8:], path[8:], ] @property def non_editable_metadata_fields(self): non_editable_fields = super(CapaDescriptor, self).non_editable_metadata_fields non_editable_fields.extend([ CapaDescriptor.due, CapaDescriptor.graceperiod, CapaDescriptor.force_save_button, CapaDescriptor.markdown, CapaDescriptor.use_latex_compiler, CapaDescriptor.show_correctness, ]) return non_editable_fields @property def problem_types(self): """ Low-level problem type introspection for content libraries filtering by problem type """ try: tree = etree.XML(self.data) except etree.XMLSyntaxError: log.error( 'Error parsing problem types from xml for capa module {}'. format(self.display_name)) return None # short-term fix to prevent errors (TNL-5057). Will be more properly addressed in TNL-4525. registered_tags = responsetypes.registry.registered_tags() return { node.tag for node in tree.iter() if node.tag in registered_tags } def index_dictionary(self): """ Return dictionary prepared with module content and type for indexing. """ xblock_body = super(CapaDescriptor, self).index_dictionary() # Removing solutions and hints, as well as script and style capa_content = re.sub( re.compile( r""" <solution>.*?</solution> | <script>.*?</script> | <style>.*?</style> | <[a-z]*hint.*?>.*?</[a-z]*hint> """, re.DOTALL | re.VERBOSE), "", self.data) capa_content = escape_html_characters(capa_content) capa_body = { "capa_content": capa_content, "display_name": self.display_name, } if "content" in xblock_body: xblock_body["content"].update(capa_body) else: xblock_body["content"] = capa_body xblock_body["content_type"] = self.INDEX_CONTENT_TYPE xblock_body["problem_types"] = list(self.problem_types) return xblock_body def has_support(self, view, functionality): """ Override the XBlock.has_support method to return appropriate value for the multi-device functionality. Returns whether the given view has support for the given functionality. """ if functionality == "multi_device": types = self.problem_types # Avoid calculating this property twice return types is not None and all( responsetypes.registry.get_class_for_tag( tag).multi_device_support for tag in types) return False def max_score(self): """ Return the problem's max score """ from capa.capa_problem import LoncapaProblem, LoncapaSystem capa_system = LoncapaSystem( ajax_url=None, anonymous_student_id=None, cache=None, can_execute_unsafe_code=None, get_python_lib_zip=None, DEBUG=None, filestore=self.runtime.resources_fs, i18n=self.runtime.service(self, "i18n"), node_path=None, render_template=None, seed=None, STATIC_URL=None, xqueue=None, matlab_api_key=None, ) lcp = LoncapaProblem( problem_text=self.data, id=self.location.html_id(), capa_system=capa_system, capa_module=self, state={}, seed=1, minimal_init=True, ) return lcp.get_max_score() # Proxy to CapaModule for access to any of its attributes answer_available = module_attr('answer_available') submit_button_name = module_attr('submit_button_name') submit_button_submitting_name = module_attr( 'submit_button_submitting_name') submit_problem = module_attr('submit_problem') choose_new_seed = module_attr('choose_new_seed') closed = module_attr('closed') get_answer = module_attr('get_answer') get_problem = module_attr('get_problem') get_problem_html = module_attr('get_problem_html') get_state_for_lcp = module_attr('get_state_for_lcp') handle_input_ajax = module_attr('handle_input_ajax') hint_button = module_attr('hint_button') handle_problem_html_error = module_attr('handle_problem_html_error') handle_ungraded_response = module_attr('handle_ungraded_response') has_submitted_answer = module_attr('has_submitted_answer') is_attempted = module_attr('is_attempted') is_correct = module_attr('is_correct') is_past_due = module_attr('is_past_due') is_submitted = module_attr('is_submitted') lcp = module_attr('lcp') make_dict_of_responses = module_attr('make_dict_of_responses') new_lcp = module_attr('new_lcp') publish_grade = module_attr('publish_grade') rescore = module_attr('rescore') reset_problem = module_attr('reset_problem') save_problem = module_attr('save_problem') set_state_from_lcp = module_attr('set_state_from_lcp') should_show_submit_button = module_attr('should_show_submit_button') should_show_reset_button = module_attr('should_show_reset_button') should_show_save_button = module_attr('should_show_save_button') update_score = module_attr('update_score')
def _generate_report(self, session): suite_stop_time = time.time() suite_time_delta = suite_stop_time - self.suite_start_time numtests = self.passed + self.failed + self.xpassed + self.xfailed generated = datetime.datetime.now() self.style_css = pkg_resources.resource_string( __name__, os.path.join('resources', 'style.css')) if PY3: self.style_css = self.style_css.decode('utf-8') if ANSI: ansi_css = [ '\n/******************************', ' * ANSI2HTML STYLES', ' ******************************/\n'] ansi_css.extend([str(r) for r in style.get_styles()]) self.style_css += '\n'.join(ansi_css) # <DF> Add user-provided CSS for path in self.config.getoption('css'): self.style_css += '\n/******************************' self.style_css += '\n * CUSTOM CSS' self.style_css += '\n * {}'.format(path) self.style_css += '\n ******************************/\n\n' with open(path, 'r') as f: self.style_css += f.read() css_href = '{0}/{1}'.format('assets', 'style.css') html_css = html.link(href=css_href, rel='stylesheet', type='text/css') if self.self_contained: html_css = html.style(raw(self.style_css)) head = html.head( html.meta(charset='utf-8'), html.title('Test Report'), html_css) class Outcome: def __init__(self, outcome, total=0, label=None, test_result=None, class_html=None): self.outcome = outcome self.label = label or outcome self.class_html = class_html or outcome self.total = total self.test_result = test_result or outcome self.generate_checkbox() self.generate_summary_item() def generate_checkbox(self): checkbox_kwargs = {'data-test-result': self.test_result.lower()} if self.total == 0: checkbox_kwargs['disabled'] = 'true' self.checkbox = html.input(type='checkbox', checked='true', onChange='filter_table(this)', name='filter_checkbox', class_='filter', hidden='true', **checkbox_kwargs) def generate_summary_item(self): self.summary_item = html.span('{0} {1}'. format(self.total, self.label), class_=self.class_html) outcomes = [Outcome('passed', self.passed), Outcome('skipped', self.skipped), Outcome('failed', self.failed), Outcome('error', self.errors, label='errors'), Outcome('xfailed', self.xfailed, label='expected failures'), Outcome('xpassed', self.xpassed, label='unexpected passes')] if self.rerun is not None: outcomes.append(Outcome('rerun', self.rerun)) summary = [html.p( '{0} tests ran in {1:.2f} seconds. '.format( numtests, suite_time_delta)), html.p('(Un)check the boxes to filter the results.', class_='filter', hidden='true')] for i, outcome in enumerate(outcomes, start=1): summary.append(outcome.checkbox) summary.append(outcome.summary_item) if i < len(outcomes): summary.append(', ') cells = [ html.th('Result', class_='sortable result initial-sort', col='result'), html.th('Test', class_='sortable', col='name'), html.th('Duration', class_='sortable numeric', col='duration'), html.th('Links')] session.config.hook.pytest_html_results_table_header(cells=cells) results = [html.h2('Results'), html.table([html.thead( html.tr(cells), html.tr([ html.th('No results found. Try to check the filters', colspan=len(cells))], id='not-found-message', hidden='true'), id='results-table-head'), self.test_logs], id='results-table')] main_js = pkg_resources.resource_string( __name__, os.path.join('resources', 'main.js')) if PY3: main_js = main_js.decode('utf-8') body = html.body( html.script(raw(main_js)), html.h1(os.path.basename(self.logfile)), html.p('Report generated on {0} at {1} by '.format( generated.strftime('%d-%b-%Y'), generated.strftime('%H:%M:%S')), html.a('pytest-html', href=__pypi_url__), ' v{0}'.format(__version__)), onLoad='init()') body.extend(self._generate_environment(session.config)) summary_prefix, summary_postfix = [], [] session.config.hook.pytest_html_results_summary( prefix=summary_prefix, summary=summary, postfix=summary_postfix) body.extend([html.h2('Summary')] + summary_prefix + summary + summary_postfix) body.extend(results) doc = html.html(head, body) unicode_doc = u'<!DOCTYPE html>\n{0}'.format(doc.unicode(indent=2)) if PY3: # Fix encoding issues, e.g. with surrogates unicode_doc = unicode_doc.encode('utf-8', errors='xmlcharrefreplace') unicode_doc = unicode_doc.decode('utf-8') return unicode_doc
class CapaModule(CapaMixin, XModule): """ An XModule implementing LonCapa format problems, implemented by way of capa.capa_problem.LoncapaProblem CapaModule.__init__ takes the same arguments as xmodule.x_module:XModule.__init__ """ icon_class = 'problem' js = { 'coffee': [ resource_string(__name__, 'js/src/capa/display.coffee'), resource_string(__name__, 'js/src/javascript_loader.coffee'), ], 'js': [ resource_string(__name__, 'js/src/collapsible.js'), resource_string(__name__, 'js/src/capa/imageinput.js'), resource_string(__name__, 'js/src/capa/schematic.js'), ] } js_module_name = "Problem" css = {'scss': [resource_string(__name__, 'css/capa/display.scss')]} def __init__(self, *args, **kwargs): """ Accepts the same arguments as xmodule.x_module:XModule.__init__ """ super(CapaModule, self).__init__(*args, **kwargs) def handle_ajax(self, dispatch, data): """ This is called by courseware.module_render, to handle an AJAX call. `data` is request.POST. Returns a json dictionary: { 'progress_changed' : True/False, 'progress' : 'none'/'in_progress'/'done', <other request-specific values here > } """ handlers = { 'problem_get': self.get_problem, 'problem_check': self.check_problem, 'problem_reset': self.reset_problem, 'problem_save': self.save_problem, 'problem_show': self.get_answer, 'score_update': self.update_score, 'input_ajax': self.handle_input_ajax, 'ungraded_response': self.handle_ungraded_response } _ = self.runtime.service(self, "i18n").ugettext generic_error_message = _( "We're sorry, there was an error with processing your request. " "Please try reloading your page and trying again.") not_found_error_message = _( "The state of this problem has changed since you loaded this page. " "Please refresh your page.") if dispatch not in handlers: return 'Error: {} is not a known capa action'.format(dispatch) before = self.get_progress() try: result = handlers[dispatch](data) except NotFoundError as err: _, _, traceback_obj = sys.exc_info() # pylint: disable=redefined-outer-name raise ProcessingError(not_found_error_message), None, traceback_obj except Exception as err: _, _, traceback_obj = sys.exc_info() # pylint: disable=redefined-outer-name raise ProcessingError(generic_error_message), None, traceback_obj after = self.get_progress() result.update({ 'progress_changed': after != before, 'progress_status': Progress.to_js_status_str(after), 'progress_detail': Progress.to_js_detail_str(after), }) return json.dumps(result, cls=ComplexEncoder)
from pkg_resources import resource_string import boto3 import yaml from troposphere import s3 from troposphere import Output, Ref, Template import cloudformation.troposphere.utils as utils # load config cfg = yaml.load(resource_string('config', 'dev_config.yml')) STACK_NAME = cfg['s3']['stack_name'] template = Template() description = 'S3 Developments Buckets' template.add_description(description) # AWSTemplateFormatVersion template.add_version('2010-09-09') s3_dev_bucket = template.add_resource( s3.Bucket('S3DevBucket', BucketName='nicor-dev', DeletionPolicy='Retain')) s3_data_bucket = template.add_resource( s3.Bucket('S3DataBucket', BucketName='nicor-data', DeletionPolicy='Retain')) # stack outputs template.add_output([ Output('S3DevBucket',
class HtmlDescriptor(HtmlBlock, XmlDescriptor, EditingDescriptor): # pylint: disable=abstract-method """ Module for putting raw html in a course """ mako_template = "widgets/html-edit.html" module_class = HtmlModule resources_dir = None filename_extension = "xml" template_dir_name = "html" show_in_read_only_mode = True js = {'js': [resource_string(__name__, 'js/src/html/edit.js')]} js_module_name = "HTMLEditingDescriptor" css = { 'scss': [ resource_string(__name__, 'css/editor/edit.scss'), resource_string(__name__, 'css/html/edit.scss') ] } # VS[compat] TODO (cpennington): Delete this method once all fall 2012 course # are being edited in the cms @classmethod def backcompat_paths(cls, filepath): """ Get paths for html and xml files. """ if filepath.endswith('.html.xml'): filepath = filepath[:-9] + '.html' # backcompat--look for html instead of xml if filepath.endswith('.html.html'): filepath = filepath[: -5] # some people like to include .html in filenames.. candidates = [] while os.sep in filepath: candidates.append(filepath) _, _, filepath = filepath.partition(os.sep) # also look for .html versions instead of .xml new_candidates = [] for candidate in candidates: if candidate.endswith('.xml'): new_candidates.append(candidate[:-4] + '.html') return candidates + new_candidates @classmethod def filter_templates(cls, template, course): """ Filter template that contains 'latex' from templates. Show them only if use_latex_compiler is set to True in course settings. """ return 'latex' not in template[ 'template_id'] or course.use_latex_compiler def get_context(self): """ an override to add in specific rendering context, in this case we need to add in a base path to our c4x content addressing scheme """ _context = EditingDescriptor.get_context(self) # Add some specific HTML rendering context when editing HTML modules where we pass # the root /c4x/ url for assets. This allows client-side substitutions to occur. _context.update({ 'base_asset_url': StaticContent.get_base_url_path_for_course_assets( self.location.course_key), 'enable_latex_compiler': self.use_latex_compiler, 'editor': self.editor }) return _context # NOTE: html descriptors are special. We do not want to parse and # export them ourselves, because that can break things (e.g. lxml # adds body tags when it exports, but they should just be html # snippets that will be included in the middle of pages. @classmethod def load_definition(cls, xml_object, system, location, id_generator): '''Load a descriptor from the specified xml_object: If there is a filename attribute, load it as a string, and log a warning if it is not parseable by etree.HTMLParser. If there is not a filename attribute, the definition is the body of the xml_object, without the root tag (do not want <html> in the middle of a page) Args: xml_object: an lxml.etree._Element containing the definition to load system: the modulestore system or runtime which caches data location: the usage id for the block--used to compute the filename if none in the xml_object id_generator: used by other impls of this method to generate the usage_id ''' filename = xml_object.get('filename') if filename is None: definition_xml = copy.deepcopy(xml_object) cls.clean_metadata_from_xml(definition_xml) return {'data': stringify_children(definition_xml)}, [] else: # html is special. cls.filename_extension is 'xml', but # if 'filename' is in the definition, that means to load # from .html # 'filename' in html pointers is a relative path # (not same as 'html/blah.html' when the pointer is in a directory itself) pointer_path = "{category}/{url_path}".format( category='html', url_path=name_to_pathname(location.block_id)) base = path(pointer_path).dirname() # log.debug("base = {0}, base.dirname={1}, filename={2}".format(base, base.dirname(), filename)) filepath = u"{base}/{name}.html".format(base=base, name=filename) # log.debug("looking for html file for {0} at {1}".format(location, filepath)) # VS[compat] # TODO (cpennington): If the file doesn't exist at the right path, # give the class a chance to fix it up. The file will be written out # again in the correct format. This should go away once the CMS is # online and has imported all current (fall 2012) courses from xml if not system.resources_fs.exists(filepath): candidates = cls.backcompat_paths(filepath) # log.debug("candidates = {0}".format(candidates)) for candidate in candidates: if system.resources_fs.exists(candidate): filepath = candidate break try: with system.resources_fs.open(filepath, encoding='utf-8') as infile: html = infile.read() # Log a warning if we can't parse the file, but don't error if not check_html(html) and len(html) > 0: msg = "Couldn't parse html in {0}, content = {1}".format( filepath, html) log.warning(msg) system.error_tracker("Warning: " + msg) definition = {'data': html} # TODO (ichuang): remove this after migration # for Fall 2012 LMS migration: keep filename (and unmangled filename) definition['filename'] = [filepath, filename] return definition, [] except ResourceNotFound as err: msg = 'Unable to load file contents at path {0}: {1} '.format( filepath, err) # add more info and re-raise raise Exception(msg), None, sys.exc_info()[2] # TODO (vshnayder): make export put things in the right places. def definition_to_xml(self, resource_fs): ''' Write <html filename="" [meta-attrs="..."]> to filename.xml, and the html string to filename.html. ''' # Write html to file, return an empty tag pathname = name_to_pathname(self.url_name) filepath = u'{category}/{pathname}.html'.format(category=self.category, pathname=pathname) resource_fs.makedirs(os.path.dirname(filepath), recreate=True) with resource_fs.open(filepath, 'wb') as filestream: html_data = self.data.encode('utf-8') filestream.write(html_data) # write out the relative name relname = path(pathname).basename() elt = etree.Element('html') elt.set("filename", relname) return elt @property def non_editable_metadata_fields(self): """ `use_latex_compiler` should not be editable in the Studio settings editor. """ non_editable_fields = super(HtmlDescriptor, self).non_editable_metadata_fields non_editable_fields.append(HtmlDescriptor.use_latex_compiler) return non_editable_fields def index_dictionary(self): xblock_body = super(HtmlDescriptor, self).index_dictionary() # Removing script and style html_content = re.sub( re.compile( r""" <script>.*?</script> | <style>.*?</style> """, re.DOTALL | re.VERBOSE), "", self.data) html_content = escape_html_characters(html_content) html_body = { "html_content": html_content, "display_name": self.display_name, } if "content" in xblock_body: xblock_body["content"].update(html_body) else: xblock_body["content"] = html_body xblock_body["content_type"] = "Text" return xblock_body
def pytest_sessionfinish(self): if not os.path.exists(os.path.dirname(self.logfile)): os.makedirs(os.path.dirname(self.logfile)) logfile = open(self.logfile, 'w', encoding='utf-8') suite_stop_time = time.time() suite_time_delta = suite_stop_time - self.suite_start_time numtests = self.passed + self.failed + self.xpassed + self.xfailed generated = datetime.datetime.now() style_css = pkg_resources.resource_string( __name__, os.path.join('resources', 'style.css')) if PY3: style_css = style_css.decode('utf-8') head = html.head( html.meta(charset='utf-8'), html.title('Test Report'), html.style(raw(style_css))) summary = [html.h2('Summary'), html.p( '{0} tests ran in {1:.2f} seconds.'.format( numtests, suite_time_delta), html.br(), html.span('{0} passed'.format( self.passed), class_='passed'), ', ', html.span('{0} skipped'.format( self.skipped), class_='skipped'), ', ', html.span('{0} failed'.format( self.failed), class_='failed'), ', ', html.span('{0} errors'.format( self.errors), class_='error'), '.', html.br(), html.span('{0} expected failures'.format( self.xfailed), class_='skipped'), ', ', html.span('{0} unexpected passes'.format( self.xpassed), class_='failed'), '.')] results = [html.h2('Results'), html.table([html.thead( html.tr([ html.th('Result', class_='sortable initial-sort result', col='result'), html.th('Test', class_='sortable', col='name'), html.th('Duration', class_='sortable numeric', col='duration'), html.th('Links')]), id='results-table-head'), html.tbody(*self.test_logs, id='results-table-body')], id='results-table')] main_js = pkg_resources.resource_string( __name__, os.path.join('resources', 'main.js')) if PY3: main_js = main_js.decode('utf-8') body = html.body( html.script(raw(main_js)), html.p('Report generated on {0} at {1}'.format( generated.strftime('%d-%b-%Y'), generated.strftime('%H:%M:%S')))) if self.environment is not None: body.append(html.h2('Environment')) body.append(html.table( [html.tr(html.td(e[0]), html.td(e[1])) for e in sorted( self.environment, key=lambda e: e[0]) if e[1]], id='environment')) body.extend(summary) body.extend(results) doc = html.html(head, body) logfile.write('<!DOCTYPE html>') unicode_doc = doc.unicode(indent=2) if PY3: # Fix encoding issues, e.g. with surrogates unicode_doc = unicode_doc.encode('utf-8', errors='xmlcharrefreplace') unicode_doc = unicode_doc.decode('utf-8') logfile.write(unicode_doc) logfile.close()
from pkg_resources import resource_string from redis.client import Script from sentry.tsdb.base import BaseTSDB from sentry.utils.dates import to_datetime, to_timestamp from sentry.utils.redis import check_cluster_versions, get_cluster_from_options from sentry.utils.versioning import Version from six.moves import reduce logger = logging.getLogger(__name__) SketchParameters = namedtuple('SketchParameters', 'depth width capacity') CountMinScript = Script( None, resource_string('sentry', 'scripts/tsdb/cmsketch.lua'), ) class RedisTSDB(BaseTSDB): """ A time series storage backend for Redis. The time series API supports three data types: * simple counters * distinct counters (number of unique elements seen) * frequency tables (a set of items ranked by most frequently observed) The backend also supports virtual nodes (``vnodes``) which controls shard distribution. This value should be set to the anticipated maximum number of
def ProcessFile(inputFilename, outDir, languageFilename, templateFilename): currentDateTime = strftime("%d/%m/%Y at %H:%M:%S") try: oneOutputFilePerMsg = language.oneOutputFilePerMsg except AttributeError: oneOutputFilePerMsg = False # open output file now if not oneOutputFilePerMsg: filename = os.path.basename(inputFilename).split('.')[0] outputFilename, outFile = OutputFile(inputFilename, filename, outDir) if not outFile: return # read the input file inputData = readFile(inputFilename) # if there's no input, return without creating output if inputData == 0: print("ERROR! input is empty!") return # read the template file if os.path.isfile(templateFilename): with open(templateFilename, 'r') as templateFile: template = templateFile.read().splitlines() elif os.path.isfile(languageFilename + '/' + templateFilename): with open(languageFilename + '/' + templateFilename, 'r') as templateFile: template = templateFile.read().splitlines() else: from pkg_resources import resource_string try: template = resource_string(language.__name__, templateFilename).decode( 'UTF-8', 'replace').splitlines() except FileNotFoundError: print("Error opening " + language.__name__ + " " + templateFilename) sys.exit(1) replacements = {} enums = Enums(inputData) ids = MsgIDs(inputData) PatchStructs(inputData) firstTime = True if "Messages" in inputData: for msg in Messages(inputData): msg["ids"] = ids try: msg["commonSubdir"] = CommonSubdir(inputFilename, outDir + "/fake") if oneOutputFilePerMsg: outputFilename, outFile = OutputFile( inputFilename, msgShortName(msg), outDir) if not outFile: continue replacements["<ENUMERATIONS>"] = language.enums( UsedEnums(msg, enums)) replacements["<MSGNAME>"] = msgName(msg) replacements["<MSGSHORTNAME>"] = msgShortName(msg) replacements["<NUMBER_OF_FIELDS>"] = str(numberOfFields(msg)) replacements["<NUMBER_OF_SUBFIELDS>"] = str( numberOfSubfields(msg)) undefinedMsgId = "UNDEFINED_MSGID" try: undefinedMsgId = language.undefinedMsgId() except AttributeError: pass try: replacements["<MSGID>"] = language.languageConst( msgID(msg, enums, undefinedMsgId)) except AttributeError: replacements["<MSGID>"] = str( msgID(msg, enums, undefinedMsgId)) replacements["<MSGSIZE>"] = str(msgSize(msg)) replacements["<MSGDESCRIPTION>"] = str( fieldItem(msg, "Description", "")).replace('\n', ' ') replacements["<ACCESSORS>"] = "\n".join( language.accessors(msg)) replacements["<DECLARATIONS>"] = "\n".join( language.declarations(msg)) replacements["<INIT_CODE>"] = "\n".join(language.initCode(msg)) replacements["<OUTPUTFILENAME>"] = outputFilename replacements["<INPUTFILENAME>"] = inputFilename replacements["<TEMPLATEFILENAME>"] = templateFilename replacements["<LANGUAGEFILENAME>"] = languageFilename replacements["<MESSAGE_PACKAGE>"] = msg[ "commonSubdir"].replace('/', '.').replace('\\', '.') replacements["<MSGDESCRIPTOR>"] = msgDescriptor( msg, inputFilename) replacements["<DATE>"] = currentDateTime replacements["<MSGALIAS>"] = msgAlias(msg) for line in template: line = DoReplacements(line, msg, replacements, firstTime) outFile.write(line) if oneOutputFilePerMsg: outfileLen = outFile.tell() outFile.close() else: firstTime = False except MessageException as e: sys.stderr.write(str(e) + '\n') outFile.close() os.remove(outputFilename) sys.exit(1) if not oneOutputFilePerMsg: outfileLen = outFile.tell() outFile.close()
#!/usr/bin/env python from setuptools import setup import json from pkg_resources import resource_string package_json = resource_string('jupyter_skeleton', 'package.json') npm_package = json.loads(package_json.decode('ascii')) setup( name=npm_package['name'], version=npm_package['version'], description=npm_package['description'], author=npm_package['author'], author_email='*****@*****.**', url=npm_package['repository']['url'], packages=['jupyter_skeleton'], package_data={'jupyter_skeleton': ['package.json', 'amd/index.js']}, )
def get_template(file_name: str) -> jinja2.Template: # this_module = __import__('bigsmoke.templates').templates template_str: str = resource_string("bigsmoke.templates", file_name).decode("UTF-8") return jinja2.Template(template_str)
def update_config(self): config_dest = os.path.join(self.jenkins_home, 'config.xml') config_dest_file = open(config_dest, 'w') config_source = pkg_resources.resource_string( 'jenkinsapi_tests.systests', 'config.xml') config_dest_file.write(config_source.encode('UTF-8'))
class CapaModule(CapaFields, XModule): """ An XModule implementing LonCapa format problems, implemented by way of capa.capa_problem.LoncapaProblem CapaModule.__init__ takes the same arguments as xmodule.x_module:XModule.__init__ """ icon_class = 'problem' js = { 'coffee': [ resource_string(__name__, 'js/src/capa/display.coffee'), resource_string(__name__, 'js/src/collapsible.coffee'), resource_string(__name__, 'js/src/javascript_loader.coffee'), ], 'js': [ resource_string(__name__, 'js/src/capa/imageinput.js'), resource_string(__name__, 'js/src/capa/schematic.js') ] } js_module_name = "Problem" css = {'scss': [resource_string(__name__, 'css/capa/display.scss')]} def __init__(self, *args, **kwargs): """ Accepts the same arguments as xmodule.x_module:XModule.__init__ """ XModule.__init__(self, *args, **kwargs) due_date = self.due if self.graceperiod is not None and due_date: self.close_date = due_date + self.graceperiod else: self.close_date = due_date if self.seed is None: self.choose_new_seed() # Need the problem location in openendedresponse to send out. Adding # it to the system here seems like the least clunky way to get it # there. self.system.set('location', self.location.url()) try: # TODO (vshnayder): move as much as possible of this work and error # checking to descriptor load time self.lcp = self.new_lcp(self.get_state_for_lcp()) # At this point, we need to persist the randomization seed # so that when the problem is re-loaded (to check/view/save) # it stays the same. # However, we do not want to write to the database # every time the module is loaded. # So we set the seed ONLY when there is not one set already if self.seed is None: self.seed = self.lcp.seed except Exception as err: msg = u'cannot create LoncapaProblem {loc}: {err}'.format( loc=self.location.url(), err=err) # TODO (vshnayder): do modules need error handlers too? # We shouldn't be switching on DEBUG. if self.system.DEBUG: log.warning(msg) # TODO (vshnayder): This logic should be general, not here--and may # want to preserve the data instead of replacing it. # e.g. in the CMS msg = u'<p>{msg}</p>'.format(msg=cgi.escape(msg)) msg += u'<p><pre>{tb}</pre></p>'.format( tb=cgi.escape(traceback.format_exc())) # create a dummy problem with error message instead of failing problem_text = ( u'<problem><text><span class="inline-error">' u'Problem {url} has an error:</span>{msg}</text></problem>' .format(url=self.location.url(), msg=msg)) self.lcp = self.new_lcp(self.get_state_for_lcp(), text=problem_text) else: # add extra info and raise raise Exception(msg), None, sys.exc_info()[2] self.set_state_from_lcp() assert self.seed is not None def choose_new_seed(self): """ Choose a new seed. """ if self.rerandomize == 'never': self.seed = 1 elif self.rerandomize == "per_student" and hasattr( self.system, 'seed'): # see comment on randomization_bin self.seed = randomization_bin(self.system.seed, self.location.url) else: self.seed = struct.unpack('i', os.urandom(4))[0] # So that sandboxed code execution can be cached, but still have an interesting # number of possibilities, cap the number of different random seeds. self.seed %= MAX_RANDOMIZATION_BINS def new_lcp(self, state, text=None): """ Generate a new Loncapa Problem """ if text is None: text = self.data return LoncapaProblem( problem_text=text, id=self.location.html_id(), state=state, seed=self.seed, system=self.system, ) def get_state_for_lcp(self): """ Give a dictionary holding the state of the module """ return { 'done': self.done, 'correct_map': self.correct_map, 'student_answers': self.student_answers, 'input_state': self.input_state, 'seed': self.seed, } def set_state_from_lcp(self): """ Set the module's state from the settings in `self.lcp` """ lcp_state = self.lcp.get_state() self.done = lcp_state['done'] self.correct_map = lcp_state['correct_map'] self.input_state = lcp_state['input_state'] self.student_answers = lcp_state['student_answers'] self.seed = lcp_state['seed'] def get_score(self): """ Access the problem's score """ return self.lcp.get_score() def max_score(self): """ Access the problem's max score """ return self.lcp.get_max_score() def get_progress(self): """ For now, just return score / max_score """ d = self.get_score() score = d['score'] total = d['total'] if total > 0: if self.weight is not None: # scale score and total by weight/total: score = score * self.weight / total total = self.weight try: return Progress(score, total) except (TypeError, ValueError): log.exception("Got bad progress") return None return None def get_html(self): """ Return some html with data about the module """ progress = self.get_progress() return self.system.render_template( 'problem_ajax.html', { 'element_id': self.location.html_id(), 'id': self.id, 'ajax_url': self.system.ajax_url, 'progress_status': Progress.to_js_status_str(progress), 'progress_detail': Progress.to_js_detail_str(progress), }) def check_button_name(self): """ Determine the name for the "check" button. Usually it is just "Check", but if this is the student's final attempt, change the name to "Final Check" """ if self.max_attempts is not None: final_check = (self.attempts >= self.max_attempts - 1) else: final_check = False return _("Final Check") if final_check else _("Check") def should_show_check_button(self): """ Return True/False to indicate whether to show the "Check" button. """ submitted_without_reset = (self.is_submitted() and self.rerandomize == "always") # If the problem is closed (past due / too many attempts) # then we do NOT show the "check" button # Also, do not show the "check" button if we're waiting # for the user to reset a randomized problem if self.closed() or submitted_without_reset: return False else: return True def should_show_reset_button(self): """ Return True/False to indicate whether to show the "Reset" button. """ is_survey_question = (self.max_attempts == 0) if self.rerandomize in ["always", "onreset"]: # If the problem is closed (and not a survey question with max_attempts==0), # then do NOT show the reset button. # If the problem hasn't been submitted yet, then do NOT show # the reset button. if (self.closed() and not is_survey_question) or not self.is_submitted(): return False else: return True # Only randomized problems need a "reset" button else: return False def should_show_save_button(self): """ Return True/False to indicate whether to show the "Save" button. """ # If the user has forced the save button to display, # then show it as long as the problem is not closed # (past due / too many attempts) if self.force_save_button: return not self.closed() else: is_survey_question = (self.max_attempts == 0) needs_reset = self.is_submitted() and self.rerandomize == "always" # If the student has unlimited attempts, and their answers # are not randomized, then we do not need a save button # because they can use the "Check" button without consequences. # # The consequences we want to avoid are: # * Using up an attempt (if max_attempts is set) # * Changing the current problem, and no longer being # able to view it (if rerandomize is "always") # # In those cases. the if statement below is false, # and the save button can still be displayed. # if self.max_attempts is None and self.rerandomize != "always": return False # If the problem is closed (and not a survey question with max_attempts==0), # then do NOT show the save button # If we're waiting for the user to reset a randomized problem # then do NOT show the save button elif (self.closed() and not is_survey_question) or needs_reset: return False else: return True def handle_problem_html_error(self, err): """ Create a dummy problem to represent any errors. Change our problem to a dummy problem containing a warning message to display to users. Returns the HTML to show to users `err` is the Exception encountered while rendering the problem HTML. """ log.exception(err.message) # TODO (vshnayder): another switch on DEBUG. if self.system.DEBUG: msg = ( u'[courseware.capa.capa_module] <font size="+1" color="red">' u'Failed to generate HTML for problem {url}</font>'.format( url=cgi.escape(self.location.url()))) msg += u'<p>Error:</p><p><pre>{msg}</pre></p>'.format( msg=cgi.escape(err.message)) msg += u'<p><pre>{tb}</pre></p>'.format( tb=cgi.escape(traceback.format_exc())) html = msg else: # We're in non-debug mode, and possibly even in production. We want # to avoid bricking of problem as much as possible # Presumably, student submission has corrupted LoncapaProblem HTML. # First, pull down all student answers student_answers = self.lcp.student_answers answer_ids = student_answers.keys() # Some inputtypes, such as dynamath, have additional "hidden" state that # is not exposed to the student. Keep those hidden # TODO: Use regex, e.g. 'dynamath' is suffix at end of answer_id hidden_state_keywords = ['dynamath'] for answer_id in answer_ids: for hidden_state_keyword in hidden_state_keywords: if answer_id.find(hidden_state_keyword) >= 0: student_answers.pop(answer_id) # Next, generate a fresh LoncapaProblem self.lcp = self.new_lcp(None) self.set_state_from_lcp() # Prepend a scary warning to the student warning = '<div class="capa_reset">'\ '<h2>Warning: The problem has been reset to its initial state!</h2>'\ 'The problem\'s state was corrupted by an invalid submission. ' \ 'The submission consisted of:'\ '<ul>' for student_answer in student_answers.values(): if student_answer != '': warning += '<li>' + cgi.escape(student_answer) + '</li>' warning += '</ul>'\ 'If this error persists, please contact the course staff.'\ '</div>' html = warning try: html += self.lcp.get_html() except Exception: # Couldn't do it. Give up log.exception("Unable to generate html from LoncapaProblem") raise return html def get_problem_html(self, encapsulate=True): """ Return html for the problem. Adds check, reset, save buttons as necessary based on the problem config and state. """ try: html = self.lcp.get_html() # If we cannot construct the problem HTML, # then generate an error message instead. except Exception as err: html = self.handle_problem_html_error(err) # The convention is to pass the name of the check button # if we want to show a check button, and False otherwise # This works because non-empty strings evaluate to True if self.should_show_check_button(): check_button = self.check_button_name() else: check_button = False content = { 'name': self.display_name_with_default, 'html': html, 'weight': self.weight, } context = { 'problem': content, 'id': self.id, 'check_button': check_button, 'reset_button': self.should_show_reset_button(), 'save_button': self.should_show_save_button(), 'answer_available': self.answer_available(), 'attempts_used': self.attempts, 'attempts_allowed': self.max_attempts, } html = self.system.render_template('problem.html', context) if encapsulate: html = u'<div id="problem_{id}" class="problem" data-url="{ajax_url}">'.format( id=self.location.html_id(), ajax_url=self.system.ajax_url) + html + "</div>" # now do all the substitutions which the LMS module_render normally does, but # we need to do here explicitly since we can get called for our HTML via AJAX html = self.system.replace_urls(html) if self.system.replace_course_urls: html = self.system.replace_course_urls(html) if self.system.replace_jump_to_id_urls: html = self.system.replace_jump_to_id_urls(html) return html def handle_ajax(self, dispatch, data): """ This is called by courseware.module_render, to handle an AJAX call. `data` is request.POST. Returns a json dictionary: { 'progress_changed' : True/False, 'progress' : 'none'/'in_progress'/'done', <other request-specific values here > } """ handlers = { 'problem_get': self.get_problem, 'problem_check': self.check_problem, 'problem_reset': self.reset_problem, 'problem_save': self.save_problem, 'problem_show': self.get_answer, 'score_update': self.update_score, 'input_ajax': self.handle_input_ajax, 'ungraded_response': self.handle_ungraded_response } generic_error_message = ( "We're sorry, there was an error with processing your request. " "Please try reloading your page and trying again.") not_found_error_message = ( "The state of this problem has changed since you loaded this page. " "Please refresh your page.") if dispatch not in handlers: return 'Error' before = self.get_progress() try: result = handlers[dispatch](data) except NotFoundError as err: _, _, traceback_obj = sys.exc_info() raise ProcessingError, (not_found_error_message, err), traceback_obj except Exception as err: _, _, traceback_obj = sys.exc_info() raise ProcessingError, (generic_error_message, err), traceback_obj after = self.get_progress() result.update({ 'progress_changed': after != before, 'progress_status': Progress.to_js_status_str(after), 'progress_detail': Progress.to_js_detail_str(after), }) return json.dumps(result, cls=ComplexEncoder) def is_past_due(self): """ Is it now past this problem's due date, including grace period? """ return (self.close_date is not None and datetime.datetime.now(UTC()) > self.close_date) def closed(self): """ Is the student still allowed to submit answers? """ if self.max_attempts is not None and self.attempts >= self.max_attempts: return True if self.is_past_due(): return True return False def is_submitted(self): """ Used to decide to show or hide RESET or CHECK buttons. Means that student submitted problem and nothing more. Problem can be completely wrong. Pressing RESET button makes this function to return False. """ # used by conditional module return self.lcp.done def is_attempted(self): """ Has the problem been attempted? used by conditional module """ return self.attempts > 0 def is_correct(self): """ True iff full points """ d = self.get_score() return d['score'] == d['total'] def answer_available(self): """ Is the user allowed to see an answer? """ if self.showanswer == '': return False elif self.showanswer == "never": return False elif self.system.user_is_staff: # This is after the 'never' check because admins can see the answer # unless the problem explicitly prevents it return True elif self.showanswer == 'attempted': return self.attempts > 0 elif self.showanswer == 'answered': # NOTE: this is slightly different from 'attempted' -- resetting the problems # makes lcp.done False, but leaves attempts unchanged. return self.lcp.done elif self.showanswer == 'closed': return self.closed() elif self.showanswer == 'finished': return self.closed() or self.is_correct() elif self.showanswer == 'past_due': return self.is_past_due() elif self.showanswer == 'always': return True return False def update_score(self, data): """ Delivers grading response (e.g. from asynchronous code checking) to the capa problem, so its score can be updated 'data' must have a key 'response' which is a string that contains the grader's response No ajax return is needed. Return empty dict. """ queuekey = data['queuekey'] score_msg = data['xqueue_body'] self.lcp.update_score(score_msg, queuekey) self.set_state_from_lcp() self.publish_grade() return dict() # No AJAX return is needed def handle_ungraded_response(self, data): """ Delivers a response from the XQueue to the capa problem The score of the problem will not be updated Args: - data (dict) must contain keys: queuekey - a key specific to this response xqueue_body - the body of the response Returns: empty dictionary No ajax return is needed, so an empty dict is returned """ queuekey = data['queuekey'] score_msg = data['xqueue_body'] # pass along the xqueue message to the problem self.lcp.ungraded_response(score_msg, queuekey) self.set_state_from_lcp() return dict() def handle_input_ajax(self, data): """ Handle ajax calls meant for a particular input in the problem Args: - data (dict) - data that should be passed to the input Returns: - dict containing the response from the input """ response = self.lcp.handle_input_ajax(data) # save any state changes that may occur self.set_state_from_lcp() return response def get_answer(self, data): """ For the "show answer" button. Returns the answers: {'answers' : answers} """ event_info = dict() event_info['problem_id'] = self.location.url() self.system.track_function('showanswer', event_info) if not self.answer_available(): raise NotFoundError('Answer is not available') else: answers = self.lcp.get_question_answers() self.set_state_from_lcp() # answers (eg <solution>) may have embedded images # but be careful, some problems are using non-string answer dicts new_answers = dict() for answer_id in answers: try: new_answer = { answer_id: self.system.replace_urls(answers[answer_id]) } except TypeError: log.debug( u'Unable to perform URL substitution on answers[%s]: %s', answer_id, answers[answer_id]) new_answer = {answer_id: answers[answer_id]} new_answers.update(new_answer) return {'answers': new_answers} # Figure out if we should move these to capa_problem? def get_problem(self, _data): """ Return results of get_problem_html, as a simple dict for json-ing. { 'html': <the-html> } Used if we want to reconfirm we have the right thing e.g. after several AJAX calls. """ return {'html': self.get_problem_html(encapsulate=False)} @staticmethod def make_dict_of_responses(data): """ Make dictionary of student responses (aka "answers") `data` is POST dictionary (Django QueryDict). The `data` dict has keys of the form 'x_y', which are mapped to key 'y' in the returned dict. For example, 'input_1_2_3' would be mapped to '1_2_3' in the returned dict. Some inputs always expect a list in the returned dict (e.g. checkbox inputs). The convention is that keys in the `data` dict that end with '[]' will always have list values in the returned dict. For example, if the `data` dict contains {'input_1[]': 'test' } then the output dict would contain {'1': ['test'] } (the value is a list). Some other inputs such as ChoiceTextInput expect a dict of values in the returned dict If the key ends with '{}' then we will assume that the value is a json encoded dict and deserialize it. For example, if the `data` dict contains {'input_1{}': '{"1_2_1": 1}'} then the output dict would contain {'1': {"1_2_1": 1} } (the value is a dictionary) Raises an exception if: -A key in the `data` dictionary does not contain at least one underscore (e.g. "input" is invalid, but "input_1" is valid) -Two keys end up with the same name in the returned dict. (e.g. 'input_1' and 'input_1[]', which both get mapped to 'input_1' in the returned dict) """ answers = dict() for key in data: # e.g. input_resistor_1 ==> resistor_1 _, _, name = key.partition('_') # If key has no underscores, then partition # will return (key, '', '') # We detect this and raise an error if not name: raise ValueError( u"{key} must contain at least one underscore".format( key=key)) else: # This allows for answers which require more than one value for # the same form input (e.g. checkbox inputs). The convention is that # if the name ends with '[]' (which looks like an array), then the # answer will be an array. # if the name ends with '{}' (Which looks like a dict), # then the answer will be a dict is_list_key = name.endswith('[]') is_dict_key = name.endswith('{}') name = name[:-2] if is_list_key or is_dict_key else name if is_list_key: val = data.getlist(key) elif is_dict_key: try: val = json.loads(data[key]) # If the submission wasn't deserializable, raise an error. except (KeyError, ValueError): raise ValueError( u"Invalid submission: {val} for {key}".format( val=data[key], key=key)) else: val = data[key] # If the name already exists, then we don't want # to override it. Raise an error instead if name in answers: raise ValueError( u"Key {name} already exists in answers dict".format( name=name)) else: answers[name] = val return answers def publish_grade(self): """ Publishes the student's current grade to the system as an event """ score = self.lcp.get_score() self.system.publish({ 'event_name': 'grade', 'value': score['score'], 'max_value': score['total'], }) def check_problem(self, data): """ Checks whether answers to a problem are correct Returns a map of correct/incorrect answers: {'success' : 'correct' | 'incorrect' | AJAX alert msg string, 'contents' : html} """ event_info = dict() event_info['state'] = self.lcp.get_state() event_info['problem_id'] = self.location.url() answers = self.make_dict_of_responses(data) event_info['answers'] = convert_files_to_filenames(answers) # Too late. Cannot submit if self.closed(): event_info['failure'] = 'closed' self.system.track_function('problem_check_fail', event_info) raise NotFoundError('Problem is closed') # Problem submitted. Student should reset before checking again if self.done and self.rerandomize == "always": event_info['failure'] = 'unreset' self.system.track_function('problem_check_fail', event_info) raise NotFoundError( 'Problem must be reset before it can be checked again') # Problem queued. Students must wait a specified waittime before they are allowed to submit if self.lcp.is_queued(): current_time = datetime.datetime.now(UTC()) prev_submit_time = self.lcp.get_recentmost_queuetime() waittime_between_requests = self.system.xqueue['waittime'] if (current_time - prev_submit_time ).total_seconds() < waittime_between_requests: msg = u'You must wait at least {wait} seconds between submissions'.format( wait=waittime_between_requests) return { 'success': msg, 'html': '' } # Prompts a modal dialog in ajax callback try: correct_map = self.lcp.grade_answers(answers) self.attempts = self.attempts + 1 self.lcp.done = True self.set_state_from_lcp() except (StudentInputError, ResponseError, LoncapaProblemError) as inst: log.warning("StudentInputError in capa_module:problem_check", exc_info=True) # If the user is a staff member, include # the full exception, including traceback, # in the response if self.system.user_is_staff: msg = u"Staff debug info: {tb}".format( tb=cgi.escape(traceback.format_exc())) # Otherwise, display just an error message, # without a stack trace else: msg = u"Error: {msg}".format(msg=inst.message) return {'success': msg} except Exception as err: if self.system.DEBUG: msg = u"Error checking problem: {}".format(err.message) msg += u'\nTraceback:\n{}'.format(traceback.format_exc()) return {'success': msg} raise self.publish_grade() # success = correct if ALL questions in this problem are correct success = 'correct' for answer_id in correct_map: if not correct_map.is_correct(answer_id): success = 'incorrect' # NOTE: We are logging both full grading and queued-grading submissions. In the latter, # 'success' will always be incorrect event_info['correct_map'] = correct_map.get_dict() event_info['success'] = success event_info['attempts'] = self.attempts self.system.track_function('problem_check', event_info) if hasattr(self.system, 'psychometrics_handler' ): # update PsychometricsData using callback self.system.psychometrics_handler(self.get_state_for_lcp()) # render problem into HTML html = self.get_problem_html(encapsulate=False) return { 'success': success, 'contents': html, } def rescore_problem(self): """ Checks whether the existing answers to a problem are correct. This is called when the correct answer to a problem has been changed, and the grade should be re-evaluated. Returns a dict with one key: {'success' : 'correct' | 'incorrect' | AJAX alert msg string } Raises NotFoundError if called on a problem that has not yet been answered, or NotImplementedError if it's a problem that cannot be rescored. Returns the error messages for exceptions occurring while performing the rescoring, rather than throwing them. """ event_info = { 'state': self.lcp.get_state(), 'problem_id': self.location.url() } if not self.lcp.supports_rescoring(): event_info['failure'] = 'unsupported' self.system.track_function('problem_rescore_fail', event_info) raise NotImplementedError( "Problem's definition does not support rescoring") if not self.done: event_info['failure'] = 'unanswered' self.system.track_function('problem_rescore_fail', event_info) raise NotFoundError( 'Problem must be answered before it can be graded again') # get old score, for comparison: orig_score = self.lcp.get_score() event_info['orig_score'] = orig_score['score'] event_info['orig_total'] = orig_score['total'] try: correct_map = self.lcp.rescore_existing_answers() except (StudentInputError, ResponseError, LoncapaProblemError) as inst: log.warning("Input error in capa_module:problem_rescore", exc_info=True) event_info['failure'] = 'input_error' self.system.track_function('problem_rescore_fail', event_info) return {'success': u"Error: {0}".format(inst.message)} except Exception as err: event_info['failure'] = 'unexpected' self.system.track_function('problem_rescore_fail', event_info) if self.system.DEBUG: msg = u"Error checking problem: {0}".format(err.message) msg += u'\nTraceback:\n' + traceback.format_exc() return {'success': msg} raise # rescoring should have no effect on attempts, so don't # need to increment here, or mark done. Just save. self.set_state_from_lcp() self.publish_grade() new_score = self.lcp.get_score() event_info['new_score'] = new_score['score'] event_info['new_total'] = new_score['total'] # success = correct if ALL questions in this problem are correct success = 'correct' for answer_id in correct_map: if not correct_map.is_correct(answer_id): success = 'incorrect' # NOTE: We are logging both full grading and queued-grading submissions. In the latter, # 'success' will always be incorrect event_info['correct_map'] = correct_map.get_dict() event_info['success'] = success event_info['attempts'] = self.attempts self.system.track_function('problem_rescore', event_info) # psychometrics should be called on rescoring requests in the same way as check-problem if hasattr(self.system, 'psychometrics_handler' ): # update PsychometricsData using callback self.system.psychometrics_handler(self.get_state_for_lcp()) return {'success': success} def save_problem(self, data): """ Save the passed in answers. Returns a dict { 'success' : bool, 'msg' : message } The message is informative on success, and an error message on failure. """ event_info = dict() event_info['state'] = self.lcp.get_state() event_info['problem_id'] = self.location.url() answers = self.make_dict_of_responses(data) event_info['answers'] = answers # Too late. Cannot submit if self.closed() and not self.max_attempts == 0: event_info['failure'] = 'closed' self.system.track_function('save_problem_fail', event_info) return {'success': False, 'msg': "Problem is closed"} # Problem submitted. Student should reset before saving # again. if self.done and self.rerandomize == "always": event_info['failure'] = 'done' self.system.track_function('save_problem_fail', event_info) return { 'success': False, 'msg': "Problem needs to be reset prior to save" } self.lcp.student_answers = answers self.set_state_from_lcp() self.system.track_function('save_problem_success', event_info) msg = "Your answers have been saved" if not self.max_attempts == 0: msg += " but not graded. Hit 'Check' to grade them." return {'success': True, 'msg': msg} def reset_problem(self, _data): """ Changes problem state to unfinished -- removes student answers, and causes problem to rerender itself. Returns a dictionary of the form: {'success': True/False, 'html': Problem HTML string } If an error occurs, the dictionary will also have an `error` key containing an error message. """ event_info = dict() event_info['old_state'] = self.lcp.get_state() event_info['problem_id'] = self.location.url() if self.closed(): event_info['failure'] = 'closed' self.system.track_function('reset_problem_fail', event_info) return {'success': False, 'error': "Problem is closed"} if not self.done: event_info['failure'] = 'not_done' self.system.track_function('reset_problem_fail', event_info) return { 'success': False, 'error': "Refresh the page and make an attempt before resetting." } if self.rerandomize in ["always", "onreset"]: # Reset random number generator seed. self.choose_new_seed() # Generate a new problem with either the previous seed or a new seed self.lcp = self.new_lcp(None) # Pull in the new problem seed self.set_state_from_lcp() event_info['new_state'] = self.lcp.get_state() self.system.track_function('reset_problem', event_info) return { 'success': True, 'html': self.get_problem_html(encapsulate=False) }
def write_default_config(target): dirname = os.path.dirname(target) if not os.path.exists(dirname): os.makedirs(dirname) with open(target, "w") as file: file.write(pkg_resources.resource_string(__name__, "antd.cfg"))
from configobj import ConfigObj from funcy import merge from hashlib import sha1 from more_itertools import first from pkg_resources import resource_string from schema import Optional, Use, And, Schema, SchemaError from dxr.exceptions import ConfigError from dxr.plugins import all_plugins_but_core, core_plugin from dxr.utils import cd, if_raises # Format version, signifying the instance format this web frontend code is # able to serve. Must match exactly; deploy will do nothing until it does. FORMAT = resource_string('dxr', 'format').strip() WORKERS_VALIDATOR = And(Use(int), lambda v: v >= 0, error='"workers" must be a non-negative integer.') class DotSection(object): """In the absense of an actual attribute, let attr lookup fall through to ``self._section[attr]``.""" def __getattr__(self, attr): if not hasattr(self, '_section'): # Happens during unpickling raise AttributeError(attr) try: val = self._section[attr]
def certificate_chain(): return pkg_resources.resource_string( __name__, _CERTIFICATE_CHAIN_RESOURCE_PATH)
def initFrameworkWrapper(frameworkName, frameworkPath, frameworkIdentifier, globals, inlineTab=None, scan_classes=None, frameworkResourceName=None): """ Load the named framework, using the identifier if that has result otherwise using the path. Also loads the information in the bridgesupport file ( either one embedded in the framework or one in a BrigeSupport library directory). """ if frameworkResourceName is None: frameworkResourceName = frameworkName if frameworkIdentifier is None: if scan_classes is None: bundle = objc.loadBundle(frameworkName, globals, bundle_path=frameworkPath) else: bundle = objc.loadBundle(frameworkName, globals, bundle_path=frameworkPath, scan_classes=scan_classes) else: try: if scan_classes is None: bundle = objc.loadBundle(frameworkName, globals, bundle_identifier=frameworkIdentifier) else: bundle = objc.loadBundle(frameworkName, globals, bundle_identifier=frameworkIdentifier, scan_classes=scan_classes) except ImportError: if scan_classes is None: bundle = objc.loadBundle(frameworkName, globals, bundle_path=frameworkPath) else: bundle = objc.loadBundle(frameworkName, globals, bundle_path=frameworkPath, scan_classes=scan_classes) # Make the objc module available, because it contains a lot of useful # functionality. globals['objc'] = objc # Explicitly push objc.super into the globals dict, that way super # calls will behave as expected in all cases. globals['super'] = objc.super # Look for metadata in the Python wrapper and prefer that over the # data in the framework or in system locations. # Needed because the system bridgesupport files are buggy. if safe_resource_exists(frameworkResourceName, "PyObjC.bridgesupport"): data = pkg_resources.resource_string(frameworkResourceName, "PyObjC.bridgesupport") _parseBridgeSupport(data, globals, frameworkName, inlineTab=inlineTab) return bundle # Look for metadata in the framework bundle path = bundle.pathForResource_ofType_inDirectory_(frameworkName, 'bridgesupport', 'BridgeSupport') if path is not None: dylib_path = bundle.pathForResource_ofType_inDirectory_( frameworkName, 'dylib', 'BridgeSupport') with open(path, 'rb') as fp: data = fp.read() if dylib_path is not None: _parseBridgeSupport(data, globals, frameworkName, dylib_path=dylib_path) else: _parseBridgeSupport(data, globals, frameworkName) # Check if we have additional metadata bundled with PyObjC if safe_resource_exists(frameworkResourceName, "PyObjCOverrides.bridgesupport"): data = pkg_resources.resource_string( frameworkResourceName, "PyObjCOverrides.bridgesupport") _parseBridgeSupport(data, globals, frameworkName, inlineTab=inlineTab) return bundle # If there is no metadata there look for metadata in the standard Library # locations fn = frameworkName + '.bridgesupport' for dn in BRIDGESUPPORT_DIRECTORIES: path = os.path.join(dn, fn) if os.path.exists(path): with open(path, 'rb') as fp: data = fp.read() # pragma: no branch dylib_path = os.path.join(dn, frameworkName + '.dylib') if os.path.exists(dylib_path): _parseBridgeSupport(data, globals, frameworkName, dylib_path=dylib_path) else: _parseBridgeSupport(data, globals, frameworkName) # Check if we have additional metadata bundled with PyObjC if safe_resource_exists(frameworkResourceName, "PyObjCOverrides.bridgesupport"): data = pkg_resources.resource_string( frameworkResourceName, "PyObjCOverrides.bridgesupport") _parseBridgeSupport(data, globals, frameworkName, inlineTab=inlineTab) return bundle return bundle
def test_root_certificates(): return pkg_resources.resource_string( __name__, _ROOT_CERTIFICATES_RESOURCE_PATH)
def template_from_resource(resource): # type: (str) -> string.Template template_str = pkg_resources.resource_string( __name__, f"java/{resource}").decode("utf-8") template = string.Template(template_str) return template
import sys as _sys import pkg_resources as _pkg_resources from vyper.compiler import compile_code, compile_codes # noqa: F401 if (_sys.version_info.major, _sys.version_info.minor) < (3, 6): # Can't be tested, as our test harness is using python3.6. raise Exception("Requires python3.6+") # pragma: no cover try: __version__ = _pkg_resources.get_distribution("vyper").version except _pkg_resources.DistributionNotFound: __version__ = "0.0.0development" try: __commit__ = _pkg_resources.resource_string( "vyper", "vyper_git_version.txt").decode("utf-8") __commit__ = __commit__[:7] except FileNotFoundError: __commit__ = "unknown"
def private_key(): return pkg_resources.resource_string(__name__, _PRIVATE_KEY_RESOURCE_PATH)
def get_yaml(): # with open("doc/karp_api_spec.yaml") as fp: # spec = fp.read() spec = pkg_resources.resource_string( "karp", "data_files/karp_api_spec.yaml").decode("utf-8") return Response(spec, mimetype="text/yaml")
def demosdm(self): lsid = self.request.form.get('lsid') # Run SDM on a species given by lsid (from ALA), followed by a Climate # Change projection. if self.request.get('REQUEST_METHOD', 'GET').upper() != 'POST': raise BadRequest('Request must be POST') # Swift params swiftsettings = getUtility(IRegistry).forInterface(ISwiftSettings) # get parameters if not lsid: raise BadRequest('Required parameter lsid missing') # we have an lsid,.... we can't really verify but at least some # data is here # find rest of parameters # FIXME: hardcoded path to environmental datasets # Get the future climate for climate change projection portal = ploneapi.portal.get() dspath = '/'.join([ defaults.DATASETS_FOLDER_ID, defaults.DATASETS_CLIMATE_FOLDER_ID, 'australia', 'australia_1km', 'RCP85_ukmo-hadgem1_2085.zip' ]) ds = portal.restrictedTraverse(dspath) dsuuid = IUUID(ds) dlinfo = IDownloadInfo(ds) dsmd = IBCCVLMetadata(ds) futureclimatelist = [] for layer in ('B05', 'B06', 'B13', 'B14'): futureclimatelist.append({ 'uuid': dsuuid, 'filename': dlinfo['filename'], 'downloadurl': dlinfo['url'], 'layer': layer, 'type': dsmd['layers'][layer]['datatype'], 'zippath': dsmd['layers'][layer]['filename'] }) # Climate change projection name cc_projection_name = os.path.splitext(dlinfo['filename'])[0] # Get the current climate for SDM dspath = '/'.join([ defaults.DATASETS_FOLDER_ID, defaults.DATASETS_CLIMATE_FOLDER_ID, 'australia', 'australia_1km', 'current.76to05.zip' ]) ds = portal.restrictedTraverse(dspath) dsuuid = IUUID(ds) dlinfo = IDownloadInfo(ds) dsmd = IBCCVLMetadata(ds) envlist = [] for layer in ('B05', 'B06', 'B13', 'B14'): envlist.append({ 'uuid': dsuuid, 'filename': dlinfo['filename'], 'downloadurl': dlinfo['url'], 'layer': layer, 'type': dsmd['layers'][layer]['datatype'], 'zippath': dsmd['layers'][layer]['filename'] }) # FIXME: we don't use a IJobTracker here for now # get toolkit and func = portal[defaults.TOOLKITS_FOLDER_ID]['demosdm'] # build job_params: job_params = { 'resolution': IBCCVLMetadata(ds)['resolution'], 'function': func.getId(), 'species_occurrence_dataset': { 'uuid': 'ala_occurrence_dataset', 'species': u'demoSDM', 'downloadurl': 'ala://ala?lsid={}'.format(lsid), }, 'environmental_datasets': envlist, 'future_climate_datasets': futureclimatelist, 'cc_projection_name': cc_projection_name } # add toolkit parameters: (all default values) # get toolkit schema schema = loadString(func.schema).schema for name, field in getFields(schema).items(): if field.default is not None: job_params[name] = field.default # add other default parameters job_params.update({ 'rescale_all_models': False, 'selected_models': 'all', 'modeling_id': 'bccvl', }) # generate script to run script = u'\n'.join([ resource_string('org.bccvl.compute', 'rscripts/bccvl.R'), resource_string('org.bccvl.compute', 'rscripts/eval.R'), func.script ]) # where to store results. result = { 'results_dir': 'swift+{}/wordpress/{}/'.format(swiftsettings.storage_url, urllib.quote_plus(lsid)), 'outputs': json.loads(func.output) } # worker hints: worker = { 'script': { 'name': '{}.R'.format(func.getId()), 'script': script }, 'files': ('species_occurrence_dataset', 'environmental_datasets', 'future_climate_datasets') } # put everything together jobdesc = { 'env': {}, 'params': job_params, 'worker': worker, 'result': result, } # create job jobtool = getUtility(IJobUtility) job = jobtool.new_job(lsid=lsid, toolkit=IUUID(func), function=func.getId(), type='demosdm') # create job context object member = ploneapi.user.get_current() context = { # we use the site object as context 'context': '/'.join(portal.getPhysicalPath()), 'jobid': job.id, 'user': { 'id': member.getUserName(), 'email': member.getProperty('email'), 'fullname': member.getProperty('fullname') }, } # all set to go build task chain now from org.bccvl.tasks.compute import demo_task from org.bccvl.tasks.plone import after_commit_task, HIGH_PRIORITY after_commit_task(demo_task, HIGH_PRIORITY, jobdesc, context) # let's hope everything works, return result # We don't create an experiment object, so we don't count stats here # let's do it manually getUtility(IStatsUtility).count_experiment( user=member.getId(), portal_type='demosdm', ) return { 'state': os.path.join(result['results_dir'], 'state.json'), 'result': os.path.join(result['results_dir'], 'proj_metadata.json'), 'jobid': job.id }
def _load(name: str) -> bytes: return pkg_resources.resource_string(__name__, name)
class StubOraService(StubHttpService): """ Stub ORA service. """ HANDLER_CLASS = StubOraHandler DUMMY_DATA = { 'submission_id': 1, 'submission_key': 'test key', 'student_response': 'Test response', 'prompt': 'Test prompt', 'rubric': pkg_resources.resource_string(__name__, "data/ora_rubric.xml"), 'max_score': 2, 'message': 'Successfully saved calibration record.', 'actual_score': 2, 'actual_rubric': pkg_resources.resource_string(__name__, "data/ora_graded_rubric.xml"), 'actual_feedback': 'Great job!', 'student_sub_count': 1, 'problem_name': 'test problem', 'problem_list_num_graded': 1, 'problem_list_num_pending': 1, 'problem_list_num_required': 0, } def __init__(self, *args, **kwargs): """ Initialize student submission state. """ super(StubOraService, self).__init__(*args, **kwargs) # Create a dict to map student ID's to their state self._students = dict() # By default, no problems are available for peer grading # You can add to this list using the `register_location` HTTP end-point # This is a dict mapping problem locations to problem names self.problems = dict() def student_state(self, student_id): """ Return the `StudentState` (named tuple) for the student with ID `student_id`. The student state can be modified by the caller. """ # Create the student state if it does not already exist if student_id not in self._students: student = StudentState() self._students[student_id] = student # Retrieve the student state return self._students[student_id] @property def problem_list(self): """ Return a list of problems available for peer grading. """ return [{ 'location': location, 'problem_name': name, 'num_graded': self.DUMMY_DATA['problem_list_num_graded'], 'num_pending': self.DUMMY_DATA['problem_list_num_pending'], 'num_required': self.DUMMY_DATA['problem_list_num_required'] } for location, name in self.problems.items() ] def register_problem(self, location, name): """ Register a new problem with `location` and `name` for peer grading. """ self.problems[location] = name
"""ACME utilities for testing.""" import datetime import itertools import os import pkg_resources import Crypto.PublicKey.RSA from acme import challenges from acme import jose from acme import messages2 KEY = jose.HashableRSAKey( Crypto.PublicKey.RSA.importKey( pkg_resources.resource_string( "acme.jose", os.path.join("testdata", "rsa512_key.pem")))) # Challenges SIMPLE_HTTPS = challenges.SimpleHTTP( token="evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ+PCt92wr+oA") DVSNI = challenges.DVSNI( r="O*\xb4-\xad\xec\x95>\xed\xa9\r0\x94\xe8\x97\x9c&6\xbf'\xb3" "\xed\x9a9nX\x0f'\\m\xe7\x12", nonce="a82d5ff8ef740d12881f6d3c2277ab2e") DNS = challenges.DNS(token="17817c66b60ce2e4012dfad92657527a") RECOVERY_CONTACT = challenges.RecoveryContact( activation_url="https://example.ca/sendrecovery/a5bd99383fb0", success_url="https://example.ca/confirmrecovery/bb1b9928932", contact="c********[email protected]") RECOVERY_TOKEN = challenges.RecoveryToken() POP = challenges.ProofOfPossession(
def _load_javaparser_launcher_source() -> bytes: return pkg_resources.resource_string(__name__, _LAUNCHER_BASENAME)